My Project
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
outputlist.h
Go to the documentation of this file.
1 /******************************************************************************
2  *
3  *
4  *
5  * Copyright (C) 1997-2015 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 <qlist.h>
22 #include "index.h" // for IndexSections
23 #include "outputgen.h"
24 
25 #define FORALLPROTO1(arg1) \
26  void forall(void (OutputGenerator::*func)(arg1),arg1)
27 #define FORALLPROTO2(arg1,arg2) \
28  void forall(void (OutputGenerator::*func)(arg1,arg2),arg1,arg2)
29 #define FORALLPROTO3(arg1,arg2,arg3) \
30  void forall(void (OutputGenerator::*func)(arg1,arg2,arg3),arg1,arg2,arg3)
31 #define FORALLPROTO4(arg1,arg2,arg3,arg4) \
32  void forall(void (OutputGenerator::*func)(arg1,arg2,arg3,arg4),arg1,arg2,arg3,arg4)
33 #define FORALLPROTO5(arg1,arg2,arg3,arg4,arg5) \
34  void forall(void (OutputGenerator::*func)(arg1,arg2,arg3,arg4,arg5),arg1,arg2,arg3,arg4,arg5)
35 #define FORALLPROTO6(arg1,arg2,arg3,arg4,arg5,arg6) \
36  void forall(void (OutputGenerator::*func)(arg1,arg2,arg3,arg4,arg5,arg6),arg1,arg2,arg3,arg4,arg5,arg6)
37 #define FORALLPROTO7(arg1,arg2,arg3,arg4,arg5,arg6,arg7) \
38  void forall(void (OutputGenerator::*func)(arg1,arg2,arg3,arg4,arg5,arg6,arg7),arg1,arg2,arg3,arg4,arg5,arg6,arg7)
39 #define FORALLPROTO8(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8) \
40  void forall(void (OutputGenerator::*func)(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8),arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8)
41 
42 class ClassDiagram;
43 class DotClassGraph;
44 class DotDirDeps;
45 class DotInclDepGraph;
46 class DotGfxHierarchyTable;
47 class SectionDict;
48 class DotGroupCollaboration;
49 class DocRoot;
50 
54 class OutputList : public OutputDocInterface
55 {
56  public:
57  OutputList(bool);
58  virtual ~OutputList();
59 
60  void add(const OutputGenerator *);
61  uint count() const { return m_outputs.count(); }
62 
63  void disableAllBut(OutputGenerator::OutputType o);
64  void enableAll();
65  void disableAll();
66  void disable(OutputGenerator::OutputType o);
67  void enable(OutputGenerator::OutputType o);
68  bool isEnabled(OutputGenerator::OutputType o);
69  void pushGeneratorState();
70  void popGeneratorState();
71 
72 
74  // OutputDocInterface implementation
76 
77  bool generateDoc(const char *fileName,int startLine,
78  Definition *ctx,MemberDef *md,const QCString &docStr,
79  bool indexWords,bool isExample,const char *exampleName=0,
80  bool singleLine=FALSE,bool linkFromIndex=FALSE);
81  void writeDoc(DocRoot *root,Definition *ctx,MemberDef *md);
82  bool parseText(const QCString &textStr);
83 
84 
85  void startIndexSection(IndexSections is)
86  { forall(&OutputGenerator::startIndexSection,is); }
87  void endIndexSection(IndexSections is)
88  { forall(&OutputGenerator::endIndexSection,is); }
89  void writePageLink(const char *name,bool first)
90  { forall(&OutputGenerator::writePageLink,name,first); }
91  void startProjectNumber()
92  { forall(&OutputGenerator::startProjectNumber); }
93  void endProjectNumber()
94  { forall(&OutputGenerator::endProjectNumber); }
95  void writeStyleInfo(int part)
96  { forall(&OutputGenerator::writeStyleInfo,part); }
97  void startFile(const char *name,const char *manName,const char *title)
98  { forall(&OutputGenerator::startFile,name,manName,title); }
99  void writeSearchInfo()
100  { forall(&OutputGenerator::writeSearchInfo); }
101  void writeFooter(const char *navPath)
102  { forall(&OutputGenerator::writeFooter,navPath); }
103  void endFile()
104  { forall(&OutputGenerator::endFile); }
105  void startTitleHead(const char *fileName)
106  { forall(&OutputGenerator::startTitleHead,fileName); }
107  void endTitleHead(const char *fileName,const char *name)
108  { forall(&OutputGenerator::endTitleHead,fileName,name); }
109  void startTitle()
110  { forall(&OutputGenerator::startTitle); }
111  void endTitle()
112  { forall(&OutputGenerator::endTitle); }
113  //void newParagraph()
114  //{ forall(&OutputGenerator::newParagraph); }
115  void startParagraph()
116  { forall(&OutputGenerator::startParagraph); }
117  void endParagraph()
118  { forall(&OutputGenerator::endParagraph); }
119  void writeString(const char *text)
120  { forall(&OutputGenerator::writeString,text); }
121  void startIndexListItem()
122  { forall(&OutputGenerator::startIndexListItem); }
123  void endIndexListItem()
124  { forall(&OutputGenerator::endIndexListItem); }
125  void startIndexList()
126  { forall(&OutputGenerator::startIndexList); }
127  void endIndexList()
128  { forall(&OutputGenerator::endIndexList); }
129  void startIndexKey()
130  { forall(&OutputGenerator::startIndexKey); }
131  void endIndexKey()
132  { forall(&OutputGenerator::endIndexKey); }
133  void startIndexValue(bool b)
134  { forall(&OutputGenerator::startIndexValue,b); }
135  void endIndexValue(const char *name,bool b)
136  { forall(&OutputGenerator::endIndexValue,name,b); }
137  void startItemList()
138  { forall(&OutputGenerator::startItemList); }
139  void endItemList()
140  { forall(&OutputGenerator::endItemList); }
141  void startIndexItem(const char *ref,const char *file)
142  { forall(&OutputGenerator::startIndexItem,ref,file); }
143  void endIndexItem(const char *ref,const char *file)
144  { forall(&OutputGenerator::endIndexItem,ref,file); }
145  void docify(const char *s)
146  { forall(&OutputGenerator::docify,s); }
147  void codify(const char *s)
148  { forall(&OutputGenerator::codify,s); }
149  void writeObjectLink(const char *ref,const char *file,
150  const char *anchor, const char *name)
151  { forall(&OutputGenerator::writeObjectLink,ref,file,anchor,name); }
152  void writeCodeLink(const char *ref,const char *file,
153  const char *anchor,const char *name,
154  const char *tooltip)
155  { forall(&OutputGenerator::writeCodeLink,ref,file,anchor,name,tooltip); }
156  void writeTooltip(const char *id, const DocLinkInfo &docInfo, const char *decl,
157  const char *desc, const SourceLinkInfo &defInfo, const SourceLinkInfo &declInfo)
158  { forall(&OutputGenerator::writeTooltip,id,docInfo,decl,desc,defInfo,declInfo); }
159  void startTextLink(const char *file,const char *anchor)
160  { forall(&OutputGenerator::startTextLink,file,anchor); }
161  void endTextLink()
162  { forall(&OutputGenerator::endTextLink); }
163  void startHtmlLink(const char *url)
164  { forall(&OutputGenerator::startHtmlLink,url); }
165  void endHtmlLink()
166  { forall(&OutputGenerator::endHtmlLink); }
167  void writeStartAnnoItem(const char *type,const char *file,
168  const char *path,const char *name)
169  { forall(&OutputGenerator::writeStartAnnoItem,type,file,path,name); }
170  void writeEndAnnoItem(const char *name)
171  { forall(&OutputGenerator::writeEndAnnoItem,name); }
172  void startTypewriter()
173  { forall(&OutputGenerator::startTypewriter); }
174  void endTypewriter()
175  { forall(&OutputGenerator::endTypewriter); }
176  void startGroupHeader(int extraLevels=0)
177  { forall(&OutputGenerator::startGroupHeader,extraLevels); }
178  void endGroupHeader(int extraLevels=0)
179  { forall(&OutputGenerator::endGroupHeader,extraLevels); }
180  //void writeListItem()
181  //{ forall(&OutputGenerator::writeListItem); }
182  void startItemListItem()
183  { forall(&OutputGenerator::startItemListItem); }
184  void endItemListItem()
185  { forall(&OutputGenerator::endItemListItem); }
186  void startMemberSections()
187  { forall(&OutputGenerator::startMemberSections); }
188  void endMemberSections()
189  { forall(&OutputGenerator::endMemberSections); }
190  void startHeaderSection()
191  { forall(&OutputGenerator::startHeaderSection); }
192  void endHeaderSection()
193  { forall(&OutputGenerator::endHeaderSection); }
194  void startMemberHeader(const char *anchor)
195  { forall(&OutputGenerator::startMemberHeader,anchor); }
196  void endMemberHeader()
197  { forall(&OutputGenerator::endMemberHeader); }
198  void startMemberSubtitle()
199  { forall(&OutputGenerator::startMemberSubtitle); }
200  void endMemberSubtitle()
201  { forall(&OutputGenerator::endMemberSubtitle); }
202  void startMemberDocList()
203  { forall(&OutputGenerator::startMemberDocList); }
204  void endMemberDocList()
205  { forall(&OutputGenerator::endMemberDocList); }
206  void startMemberList()
207  { forall(&OutputGenerator::startMemberList); }
208  void endMemberList()
209  { forall(&OutputGenerator::endMemberList); }
210  void startInlineHeader()
211  { forall(&OutputGenerator::startInlineHeader); }
212  void endInlineHeader()
213  { forall(&OutputGenerator::endInlineHeader); }
214  void startAnonTypeScope(int i1)
215  { forall(&OutputGenerator::startAnonTypeScope,i1); }
216  void endAnonTypeScope(int i1)
217  { forall(&OutputGenerator::endAnonTypeScope,i1); }
218  void startMemberItem(const char *anchor,int i1,const char *id=0)
219  { forall(&OutputGenerator::startMemberItem,anchor,i1,id); }
220  void endMemberItem()
221  { forall(&OutputGenerator::endMemberItem); }
222  void startMemberTemplateParams()
223  { forall(&OutputGenerator::startMemberTemplateParams); }
224  void endMemberTemplateParams(const char *anchor,const char *inheritId)
225  { forall(&OutputGenerator::endMemberTemplateParams,anchor,inheritId); }
226  void startMemberGroupHeader(bool b)
227  { forall(&OutputGenerator::startMemberGroupHeader,b); }
228  void endMemberGroupHeader()
229  { forall(&OutputGenerator::endMemberGroupHeader); }
230  void startMemberGroupDocs()
231  { forall(&OutputGenerator::startMemberGroupDocs); }
232  void endMemberGroupDocs()
233  { forall(&OutputGenerator::endMemberGroupDocs); }
234  void startMemberGroup()
235  { forall(&OutputGenerator::startMemberGroup); }
236  void endMemberGroup(bool last)
237  { forall(&OutputGenerator::endMemberGroup,last); }
238  void insertMemberAlign(bool templ=FALSE)
239  { forall(&OutputGenerator::insertMemberAlign,templ); }
240  void writeRuler()
241  { forall(&OutputGenerator::writeRuler); }
242  void writeAnchor(const char *fileName,const char *name)
243  { forall(&OutputGenerator::writeAnchor,fileName,name); }
244  void startCodeFragment()
245  { forall(&OutputGenerator::startCodeFragment); }
246  void endCodeFragment()
247  { forall(&OutputGenerator::endCodeFragment); }
248  void startCodeLine(bool hasLineNumbers)
249  { forall(&OutputGenerator::startCodeLine,hasLineNumbers); }
250  void endCodeLine()
251  { forall(&OutputGenerator::endCodeLine); }
252  void writeLineNumber(const char *ref,const char *file,const char *anchor,
253  int lineNumber)
254  { forall(&OutputGenerator::writeLineNumber,ref,file,anchor,lineNumber); }
255  void startEmphasis()
256  { forall(&OutputGenerator::startEmphasis); }
257  void endEmphasis()
258  { forall(&OutputGenerator::endEmphasis); }
259  void writeChar(char c)
260  { forall(&OutputGenerator::writeChar,c); }
261  void startMemberDoc(const char *clName,const char *memName,
262  const char *anchor,const char *title,
263  int memCount,int memTotal,bool showInline)
264  { forall(&OutputGenerator::startMemberDoc,clName,memName,anchor,title,memCount,memTotal,showInline); }
265  void endMemberDoc(bool hasArgs)
266  { forall(&OutputGenerator::endMemberDoc,hasArgs); }
267  void startDoxyAnchor(const char *fName,const char *manName,
268  const char *anchor, const char *name,
269  const char *args)
270  { forall(&OutputGenerator::startDoxyAnchor,fName,manName,anchor,name,args); }
271  void endDoxyAnchor(const char *fn,const char *anchor)
272  { forall(&OutputGenerator::endDoxyAnchor,fn,anchor); }
273  void writeLatexSpacing()
274  { forall(&OutputGenerator::writeLatexSpacing); }
275  void startDescription()
276  { forall(&OutputGenerator::startDescription); }
277  void endDescription()
278  { forall(&OutputGenerator::endDescription); }
279  void startDescItem()
280  { forall(&OutputGenerator::startDescItem); }
281  void endDescItem()
282  { forall(&OutputGenerator::endDescItem); }
283  void startDescForItem()
284  { forall(&OutputGenerator::startDescForItem); }
285  void endDescForItem()
286  { forall(&OutputGenerator::endDescForItem); }
287  void startSubsection()
288  { forall(&OutputGenerator::startSubsection); }
289  void endSubsection()
290  { forall(&OutputGenerator::endSubsection); }
291  void startSubsubsection()
292  { forall(&OutputGenerator::startSubsubsection); }
293  void endSubsubsection()
294  { forall(&OutputGenerator::endSubsubsection); }
295  void startCenter()
296  { forall(&OutputGenerator::startCenter); }
297  void endCenter()
298  { forall(&OutputGenerator::endCenter); }
299  void startSmall()
300  { forall(&OutputGenerator::startSmall); }
301  void endSmall()
302  { forall(&OutputGenerator::endSmall); }
303  void lineBreak(const char *style=0)
304  { forall(&OutputGenerator::lineBreak,style); }
305  void startBold()
306  { forall(&OutputGenerator::startBold); }
307  void endBold()
308  { forall(&OutputGenerator::endBold); }
309  void startMemberDescription(const char *anchor,const char *inheritId=0)
310  { forall(&OutputGenerator::startMemberDescription,anchor,inheritId); }
311  void endMemberDescription()
312  { forall(&OutputGenerator::endMemberDescription); }
313  void startMemberDeclaration()
314  { forall(&OutputGenerator::startMemberDeclaration); }
315  void endMemberDeclaration(const char *anchor,const char *inheritId)
316  { forall(&OutputGenerator::endMemberDeclaration,anchor,inheritId); }
317  void writeInheritedSectionTitle(const char *id, const char *ref,
318  const char *file, const char *anchor,
319  const char *title,const char *name)
320  { forall(&OutputGenerator::writeInheritedSectionTitle,id,ref,
321  file,anchor,title,name); }
322  void startSimpleSect(SectionTypes t,const char *file,const char *anchor,
323  const char *title)
324  { forall(&OutputGenerator::startSimpleSect,t,file,anchor,title); }
325  void endSimpleSect()
326  { forall(&OutputGenerator::endSimpleSect); }
327  void startParamList(ParamListTypes t,const char *title)
328  { forall(&OutputGenerator::startParamList,t,title); }
329  void endParamList()
330  { forall(&OutputGenerator::endParamList); }
331  void startIndent()
332  { forall(&OutputGenerator::startIndent); }
333  void endIndent()
334  { forall(&OutputGenerator::endIndent); }
335  void startSection(const char *lab,const char *title,SectionInfo::SectionType t)
336  { forall(&OutputGenerator::startSection,lab,title,t); }
337  void endSection(const char *lab,SectionInfo::SectionType t)
338  { forall(&OutputGenerator::endSection,lab,t); }
339  void addIndexItem(const char *s1,const char *s2)
340  { forall(&OutputGenerator::addIndexItem,s1,s2); }
341  void writeSynopsis()
342  { forall(&OutputGenerator::writeSynopsis); }
343  void startClassDiagram()
344  { forall(&OutputGenerator::startClassDiagram); }
345  void endClassDiagram(const ClassDiagram &d,const char *f,const char *n)
346  { forall(&OutputGenerator::endClassDiagram,d,f,n); }
347  void startPageRef()
348  { forall(&OutputGenerator::startPageRef); }
349  void endPageRef(const char *c,const char *a)
350  { forall(&OutputGenerator::endPageRef,c,a); }
351  void startQuickIndices()
352  { forall(&OutputGenerator::startQuickIndices); }
353  void endQuickIndices()
354  { forall(&OutputGenerator::endQuickIndices); }
355  void writeSplitBar(const char *name)
356  { forall(&OutputGenerator::writeSplitBar,name); }
357  void writeNavigationPath(const char *s)
358  { forall(&OutputGenerator::writeNavigationPath,s); }
359  void writeLogo()
360  { forall(&OutputGenerator::writeLogo); }
361  void writeQuickLinks(bool compact,HighlightedItem hli,const char *file)
362  { forall(&OutputGenerator::writeQuickLinks,compact,hli,file); }
363  void writeSummaryLink(const char *file,const char *anchor,const char *title,bool first)
364  { forall(&OutputGenerator::writeSummaryLink,file,anchor,title,first); }
365  void startContents()
366  { forall(&OutputGenerator::startContents); }
367  void endContents()
368  { forall(&OutputGenerator::endContents); }
369  void writeNonBreakableSpace(int num)
370  { forall(&OutputGenerator::writeNonBreakableSpace,num); }
371  void startDescTable(const char *title)
372  { forall(&OutputGenerator::startDescTable,title); }
373  void endDescTable()
374  { forall(&OutputGenerator::endDescTable); }
375  void startDescTableRow()
376  { forall(&OutputGenerator::startDescTableRow); }
377  void endDescTableRow()
378  { forall(&OutputGenerator::endDescTableRow); }
379  void startDescTableTitle()
380  { forall(&OutputGenerator::startDescTableTitle); }
381  void endDescTableTitle()
382  { forall(&OutputGenerator::endDescTableTitle); }
383  void startDescTableData()
384  { forall(&OutputGenerator::startDescTableData); }
385  void endDescTableData()
386  { forall(&OutputGenerator::endDescTableData); }
387  void startDotGraph()
388  { forall(&OutputGenerator::startDotGraph); }
389  void endDotGraph(const DotClassGraph &g)
390  { forall(&OutputGenerator::endDotGraph,g); }
391  void startInclDepGraph()
392  { forall(&OutputGenerator::startInclDepGraph); }
393  void endInclDepGraph(const DotInclDepGraph &g)
394  { forall(&OutputGenerator::endInclDepGraph,g); }
395  void startCallGraph()
396  { forall(&OutputGenerator::startCallGraph); }
397  void endCallGraph(const DotCallGraph &g)
398  { forall(&OutputGenerator::endCallGraph,g); }
399  void startDirDepGraph()
400  { forall(&OutputGenerator::startDirDepGraph); }
401  void endDirDepGraph(const DotDirDeps &g)
402  { forall(&OutputGenerator::endDirDepGraph,g); }
403  void startGroupCollaboration()
404  { forall(&OutputGenerator::startGroupCollaboration); }
405  void endGroupCollaboration(const DotGroupCollaboration &g)
406  { forall(&OutputGenerator::endGroupCollaboration,g); }
407  void writeGraphicalHierarchy(const DotGfxHierarchyTable &g)
408  { forall(&OutputGenerator::writeGraphicalHierarchy,g); }
409  void startTextBlock(bool dense=FALSE)
410  { forall(&OutputGenerator::startTextBlock,dense); }
411  void endTextBlock(bool paraBreak=FALSE)
412  { forall(&OutputGenerator::endTextBlock,paraBreak); }
413  void lastIndexPage()
414  { forall(&OutputGenerator::lastIndexPage); }
415  void startMemberDocPrefixItem()
416  { forall(&OutputGenerator::startMemberDocPrefixItem); }
417  void endMemberDocPrefixItem()
418  { forall(&OutputGenerator::endMemberDocPrefixItem); }
419  void startMemberDocName(bool align)
420  { forall(&OutputGenerator::startMemberDocName,align); }
421  void endMemberDocName()
422  { forall(&OutputGenerator::endMemberDocName); }
423  void startParameterType(bool first,const char *key)
424  { forall(&OutputGenerator::startParameterType,first,key); }
425  void endParameterType()
426  { forall(&OutputGenerator::endParameterType); }
427  void startParameterName(bool one)
428  { forall(&OutputGenerator::startParameterName,one); }
429  void endParameterName(bool last,bool one,bool bracket)
430  { forall(&OutputGenerator::endParameterName,last,one,bracket); }
431  void startParameterList(bool openBracket)
432  { forall(&OutputGenerator::startParameterList,openBracket); }
433  void endParameterList()
434  { forall(&OutputGenerator::endParameterList); }
435  void exceptionEntry(const char* prefix,bool closeBracket)
436  { forall(&OutputGenerator::exceptionEntry,prefix,closeBracket); }
437 
438  void startConstraintList(const char *header)
439  { forall(&OutputGenerator::startConstraintList,header); }
440  void startConstraintParam()
441  { forall(&OutputGenerator::startConstraintParam); }
442  void endConstraintParam()
443  { forall(&OutputGenerator::endConstraintParam); }
444  void startConstraintType()
445  { forall(&OutputGenerator::startConstraintType); }
446  void endConstraintType()
447  { forall(&OutputGenerator::endConstraintType); }
448  void startConstraintDocs()
449  { forall(&OutputGenerator::startConstraintDocs); }
450  void endConstraintDocs()
451  { forall(&OutputGenerator::endConstraintDocs); }
452  void endConstraintList()
453  { forall(&OutputGenerator::endConstraintList); }
454 
455  void startMemberDocSimple(bool b)
456  { forall(&OutputGenerator::startMemberDocSimple,b); }
457  void endMemberDocSimple(bool b)
458  { forall(&OutputGenerator::endMemberDocSimple,b); }
459  void startInlineMemberType()
460  { forall(&OutputGenerator::startInlineMemberType); }
461  void endInlineMemberType()
462  { forall(&OutputGenerator::endInlineMemberType); }
463  void startInlineMemberName()
464  { forall(&OutputGenerator::startInlineMemberName); }
465  void endInlineMemberName()
466  { forall(&OutputGenerator::endInlineMemberName); }
467  void startInlineMemberDoc()
468  { forall(&OutputGenerator::startInlineMemberDoc); }
469  void endInlineMemberDoc()
470  { forall(&OutputGenerator::endInlineMemberDoc); }
471 
472  void startLabels()
473  { forall(&OutputGenerator::startLabels); }
474  void writeLabel(const char *l,bool isLast)
475  { forall(&OutputGenerator::writeLabel,l,isLast); }
476  void endLabels()
477  { forall(&OutputGenerator::endLabels); }
478 
479  void startFontClass(const char *c)
480  { forall(&OutputGenerator::startFontClass,c); }
481  void endFontClass()
482  { forall(&OutputGenerator::endFontClass); }
483  void writeCodeAnchor(const char *name)
484  { forall(&OutputGenerator::writeCodeAnchor,name); }
485  void setCurrentDoc(Definition *context,const char *anchor,bool isSourceFile)
486  { forall(&OutputGenerator::setCurrentDoc,context,anchor,isSourceFile); }
487  void addWord(const char *word,bool hiPriority)
488  { forall(&OutputGenerator::addWord,word,hiPriority); }
489 
490  void startPlainFile(const char *name)
491  {
492  QListIterator<OutputGenerator> it(m_outputs);
493  OutputGenerator *og;
494  for (;(og=it.current());++it)
495  {
496  if (og->isEnabled()) (og->startPlainFile)(name);
497  }
498  }
499  void endPlainFile()
500  {
501  QListIterator<OutputGenerator> it(m_outputs);
502  OutputGenerator *og;
503  for (;(og=it.current());++it)
504  {
505  if (og->isEnabled()) (og->endPlainFile)();
506  }
507  }
508 
509  private:
510  void debug();
511  void clear();
512 
513  void forall(void (OutputGenerator::*func)());
514  FORALLPROTO1(const char *);
515  FORALLPROTO1(char);
516  FORALLPROTO1(IndexSections);
517  FORALLPROTO1(int);
518  FORALLPROTO1(const DotClassGraph &);
519  FORALLPROTO1(const DotInclDepGraph &);
520  FORALLPROTO1(const DotCallGraph &);
521  FORALLPROTO1(const DotGroupCollaboration &);
522  FORALLPROTO1(const DotDirDeps &);
523  FORALLPROTO1(const DotGfxHierarchyTable &);
524  FORALLPROTO1(SectionTypes);
525 #if defined(HAS_BOOL_TYPE) || defined(Q_HAS_BOOL_TYPE)
526  FORALLPROTO1(bool);
527  FORALLPROTO2(bool,int);
528  FORALLPROTO2(bool,bool);
529  FORALLPROTO2(const char *,bool);
530  FORALLPROTO4(const char *,const char *,const char *,int);
531 #endif
532  FORALLPROTO2(int,bool);
533  FORALLPROTO2(bool,const char *);
534  FORALLPROTO2(ParamListTypes,const char *);
535  FORALLPROTO2(const char *,const char *);
536  FORALLPROTO2(const char *,int);
537  FORALLPROTO2(const char *,SectionInfo::SectionType);
538  FORALLPROTO3(bool,HighlightedItem,const char *);
539  FORALLPROTO3(bool,bool,bool);
540  FORALLPROTO3(const char *,const char *,bool);
541  FORALLPROTO3(const char *,int,const char *);
542  FORALLPROTO3(const char *,const char *,SectionInfo::SectionType);
543  FORALLPROTO3(uchar,uchar,uchar);
544  FORALLPROTO3(const char *,const char *,const char *);
545  FORALLPROTO3(const ClassDiagram &,const char *,const char *);
546  FORALLPROTO3(Definition*,const char *,bool);
547  FORALLPROTO4(SectionTypes,const char *,const char *,const char *);
548  FORALLPROTO4(const char *,const char *,const char *,const char *);
549  FORALLPROTO4(const char *,const char *,const char *,bool);
550  FORALLPROTO5(const char *,const char *,const char *,const char *,const char *);
551  FORALLPROTO5(const char *,const char *,const char *,const char *,bool);
552  FORALLPROTO6(const char *,const char *,const char *,const char *,const char *,const char *);
553  FORALLPROTO6(const char *,const DocLinkInfo &,const char *,const char *,const SourceLinkInfo &,const SourceLinkInfo &);
554  FORALLPROTO7(const char *,const char *,const char *,const char *,int,int,bool);
555 
556  OutputList(const OutputList &ol);
557  QList<OutputGenerator> m_outputs;
558 };
559 
560 #endif