src/outputlist.h

   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
  51 /** Class representing a list of output generators that are written to
  52  *  in parallel.
  53  */
  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
  73     //////////////////////////////////////////////////
  74     // OutputDocInterface implementation
  75     //////////////////////////////////////////////////
  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(const char *classDef=0)
 116     { forall(&OutputGenerator::startParagraph,classDef); }
 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, int typ = 2)
 195     { forall(&OutputGenerator::startMemberHeader,anchor,typ); }
 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 insertMemberAlignLeft(int typ=0, bool templ=FALSE)
 241     { forall(&OutputGenerator::insertMemberAlignLeft,typ,templ); }
 242     void writeRuler()
 243     { forall(&OutputGenerator::writeRuler); }
 244     void writeAnchor(const char *fileName,const char *name)
 245     { forall(&OutputGenerator::writeAnchor,fileName,name); }
 246     void startCodeFragment()
 247     { forall(&OutputGenerator::startCodeFragment); }
 248     void endCodeFragment()
 249     { forall(&OutputGenerator::endCodeFragment); }
 250     void startCodeLine(bool hasLineNumbers)
 251     { forall(&OutputGenerator::startCodeLine,hasLineNumbers); }
 252     void endCodeLine()
 253     { forall(&OutputGenerator::endCodeLine); }
 254     void writeLineNumber(const char *ref,const char *file,const char *anchor,
 255                          int lineNumber)
 256     { forall(&OutputGenerator::writeLineNumber,ref,file,anchor,lineNumber); }
 257     void startEmphasis()
 258     { forall(&OutputGenerator::startEmphasis); }
 259     void endEmphasis()
 260     { forall(&OutputGenerator::endEmphasis); }
 261     void writeChar(char c)
 262     { forall(&OutputGenerator::writeChar,c); }
 263     void startMemberDoc(const char *clName,const char *memName,
 264                         const char *anchor,const char *title,
 265                         int memCount,int memTotal,bool showInline)
 266     { forall(&OutputGenerator::startMemberDoc,clName,memName,anchor,title,memCount,memTotal,showInline); }
 267     void endMemberDoc(bool hasArgs)
 268     { forall(&OutputGenerator::endMemberDoc,hasArgs); }
 269     void startDoxyAnchor(const char *fName,const char *manName,
 270                          const char *anchor, const char *name,
 271                          const char *args)
 272     { forall(&OutputGenerator::startDoxyAnchor,fName,manName,anchor,name,args); }
 273     void endDoxyAnchor(const char *fn,const char *anchor)
 274     { forall(&OutputGenerator::endDoxyAnchor,fn,anchor); }
 275     void writeLatexSpacing()
 276     { forall(&OutputGenerator::writeLatexSpacing); }
 277     void startDescription()
 278     { forall(&OutputGenerator::startDescription); }
 279     void endDescription()
 280     { forall(&OutputGenerator::endDescription); }
 281     void startDescItem()
 282     { forall(&OutputGenerator::startDescItem); }
 283     void endDescItem()
 284     { forall(&OutputGenerator::endDescItem); }
 285     void startDescForItem()
 286     { forall(&OutputGenerator::startDescForItem); }
 287     void endDescForItem()
 288     { forall(&OutputGenerator::endDescForItem); }
 289     void startSubsection()
 290     { forall(&OutputGenerator::startSubsection); }
 291     void endSubsection()
 292     { forall(&OutputGenerator::endSubsection); }
 293     void startSubsubsection()
 294     { forall(&OutputGenerator::startSubsubsection); }
 295     void endSubsubsection()
 296     { forall(&OutputGenerator::endSubsubsection); }
 297     void startCenter()
 298     { forall(&OutputGenerator::startCenter); }
 299     void endCenter()
 300     { forall(&OutputGenerator::endCenter); }
 301     void startSmall()
 302     { forall(&OutputGenerator::startSmall); }
 303     void endSmall()
 304     { forall(&OutputGenerator::endSmall); }
 305     void lineBreak(const char *style=0)
 306     { forall(&OutputGenerator::lineBreak,style); }
 307     void startBold()
 308     { forall(&OutputGenerator::startBold); }
 309     void endBold()
 310     { forall(&OutputGenerator::endBold); }
 311     void startMemberDescription(const char *anchor,const char *inheritId=0, bool typ = false)
 312     { forall(&OutputGenerator::startMemberDescription,anchor,inheritId, typ); }
 313     void endMemberDescription()
 314     { forall(&OutputGenerator::endMemberDescription); }
 315     void startMemberDeclaration()
 316     { forall(&OutputGenerator::startMemberDeclaration); }
 317     void endMemberDeclaration(const char *anchor,const char *inheritId)
 318     { forall(&OutputGenerator::endMemberDeclaration,anchor,inheritId); }
 319     void writeInheritedSectionTitle(const char *id,   const char *ref,
 320                                     const char *file, const char *anchor,
 321                                     const char *title,const char *name)
 322     { forall(&OutputGenerator::writeInheritedSectionTitle,id,ref,
 323                                     file,anchor,title,name); }
 324     void startExamples()
 325     { forall(&OutputGenerator::startExamples); }
 326     void endExamples()
 327     { forall(&OutputGenerator::endExamples); }
 328     void startParamList(ParamListTypes t,const char *title)
 329     { forall(&OutputGenerator::startParamList,t,title); }
 330     void endParamList()
 331     { forall(&OutputGenerator::endParamList); }
 332     void startIndent()
 333     { forall(&OutputGenerator::startIndent); }
 334     void endIndent()
 335     { forall(&OutputGenerator::endIndent); }
 336     void startSection(const char *lab,const char *title,SectionInfo::SectionType t)
 337     { forall(&OutputGenerator::startSection,lab,title,t); }
 338     void endSection(const char *lab,SectionInfo::SectionType t)
 339     { forall(&OutputGenerator::endSection,lab,t); }
 340     void addIndexItem(const char *s1,const char *s2)
 341     { forall(&OutputGenerator::addIndexItem,s1,s2); }
 342     void writeSynopsis()
 343     { forall(&OutputGenerator::writeSynopsis); }
 344     void startClassDiagram()
 345     { forall(&OutputGenerator::startClassDiagram); }
 346     void endClassDiagram(const ClassDiagram &d,const char *f,const char *n)
 347     { forall(&OutputGenerator::endClassDiagram,d,f,n); }
 348     void startPageRef()
 349     { forall(&OutputGenerator::startPageRef); }
 350     void endPageRef(const char *c,const char *a)
 351     { forall(&OutputGenerator::endPageRef,c,a); }
 352     void startQuickIndices()
 353     { forall(&OutputGenerator::startQuickIndices); }
 354     void endQuickIndices()
 355     { forall(&OutputGenerator::endQuickIndices); }
 356     void writeSplitBar(const char *name)
 357     { forall(&OutputGenerator::writeSplitBar,name); }
 358     void writeNavigationPath(const char *s)
 359     { forall(&OutputGenerator::writeNavigationPath,s); }
 360     void writeLogo()
 361     { forall(&OutputGenerator::writeLogo); }
 362     void writeQuickLinks(bool compact,HighlightedItem hli,const char *file)
 363     { forall(&OutputGenerator::writeQuickLinks,compact,hli,file); }
 364     void writeSummaryLink(const char *file,const char *anchor,const char *title,bool first)
 365     { forall(&OutputGenerator::writeSummaryLink,file,anchor,title,first); }
 366     void startContents()
 367     { forall(&OutputGenerator::startContents); }
 368     void endContents()
 369     { forall(&OutputGenerator::endContents); }
 370     void startPageDoc(const char *pageTitle)
 371     { forall(&OutputGenerator::startPageDoc, pageTitle); }
 372     void endPageDoc()
 373     { forall(&OutputGenerator::endPageDoc); }
 374     void writeNonBreakableSpace(int num)
 375     { forall(&OutputGenerator::writeNonBreakableSpace,num); }
 376     void startDescTable(const char *title)
 377     { forall(&OutputGenerator::startDescTable,title); }
 378     void endDescTable()
 379     { forall(&OutputGenerator::endDescTable); }
 380     void startDescTableRow()
 381     { forall(&OutputGenerator::startDescTableRow); }
 382     void endDescTableRow()
 383     { forall(&OutputGenerator::endDescTableRow); }
 384     void startDescTableTitle()
 385     { forall(&OutputGenerator::startDescTableTitle); }
 386     void endDescTableTitle()
 387     { forall(&OutputGenerator::endDescTableTitle); }
 388     void startDescTableData()
 389     { forall(&OutputGenerator::startDescTableData); }
 390     void endDescTableData()
 391     { forall(&OutputGenerator::endDescTableData); }
 392     void startDotGraph()
 393     { forall(&OutputGenerator::startDotGraph); }
 394     void endDotGraph(const DotClassGraph &g)
 395     { forall(&OutputGenerator::endDotGraph,g); }
 396     void startInclDepGraph()
 397     { forall(&OutputGenerator::startInclDepGraph); }
 398     void endInclDepGraph(const DotInclDepGraph &g)
 399     { forall(&OutputGenerator::endInclDepGraph,g); }
 400     void startCallGraph()
 401     { forall(&OutputGenerator::startCallGraph); }
 402     void endCallGraph(const DotCallGraph &g)
 403     { forall(&OutputGenerator::endCallGraph,g); }
 404     void startDirDepGraph()
 405     { forall(&OutputGenerator::startDirDepGraph); }
 406     void endDirDepGraph(const DotDirDeps &g)
 407     { forall(&OutputGenerator::endDirDepGraph,g); }
 408     void startGroupCollaboration()
 409     { forall(&OutputGenerator::startGroupCollaboration); }
 410     void endGroupCollaboration(const DotGroupCollaboration &g)
 411     { forall(&OutputGenerator::endGroupCollaboration,g); }
 412     void writeGraphicalHierarchy(const DotGfxHierarchyTable &g)
 413     { forall(&OutputGenerator::writeGraphicalHierarchy,g); }
 414     void startTextBlock(bool dense=FALSE)
 415     { forall(&OutputGenerator::startTextBlock,dense); }
 416     void endTextBlock(bool paraBreak=FALSE)
 417     { forall(&OutputGenerator::endTextBlock,paraBreak); }
 418     void lastIndexPage()
 419     { forall(&OutputGenerator::lastIndexPage); }
 420     void startMemberDocPrefixItem()
 421     { forall(&OutputGenerator::startMemberDocPrefixItem); }
 422     void endMemberDocPrefixItem()
 423     { forall(&OutputGenerator::endMemberDocPrefixItem); }
 424     void startMemberDocName(bool align)
 425     { forall(&OutputGenerator::startMemberDocName,align); }
 426     void endMemberDocName()
 427     { forall(&OutputGenerator::endMemberDocName); }
 428     void startParameterType(bool first,const char *key)
 429     { forall(&OutputGenerator::startParameterType,first,key); }
 430     void endParameterType()
 431     { forall(&OutputGenerator::endParameterType); }
 432     void startParameterName(bool one)
 433     { forall(&OutputGenerator::startParameterName,one); }
 434     void endParameterName(bool last,bool one,bool bracket)
 435     { forall(&OutputGenerator::endParameterName,last,one,bracket); }
 436     void startParameterList(bool openBracket)
 437     { forall(&OutputGenerator::startParameterList,openBracket); }
 438     void endParameterList()
 439     { forall(&OutputGenerator::endParameterList); }
 440     void exceptionEntry(const char* prefix,bool closeBracket)
 441     { forall(&OutputGenerator::exceptionEntry,prefix,closeBracket); }
 442
 443     void startConstraintList(const char *header)
 444     { forall(&OutputGenerator::startConstraintList,header); }
 445     void startConstraintParam()
 446     { forall(&OutputGenerator::startConstraintParam); }
 447     void endConstraintParam()
 448     { forall(&OutputGenerator::endConstraintParam); }
 449     void startConstraintType()
 450     { forall(&OutputGenerator::startConstraintType); }
 451     void endConstraintType()
 452     { forall(&OutputGenerator::endConstraintType); }
 453     void startConstraintDocs()
 454     { forall(&OutputGenerator::startConstraintDocs); }
 455     void endConstraintDocs()
 456     { forall(&OutputGenerator::endConstraintDocs); }
 457     void endConstraintList()
 458     { forall(&OutputGenerator::endConstraintList); }
 459
 460     void startMemberDocSimple(bool b)
 461     { forall(&OutputGenerator::startMemberDocSimple,b); }
 462     void endMemberDocSimple(bool b)
 463     { forall(&OutputGenerator::endMemberDocSimple,b); }
 464     void startInlineMemberType()
 465     { forall(&OutputGenerator::startInlineMemberType); }
 466     void endInlineMemberType()
 467     { forall(&OutputGenerator::endInlineMemberType); }
 468     void startInlineMemberName()
 469     { forall(&OutputGenerator::startInlineMemberName); }
 470     void endInlineMemberName()
 471     { forall(&OutputGenerator::endInlineMemberName); }
 472     void startInlineMemberDoc()
 473     { forall(&OutputGenerator::startInlineMemberDoc); }
 474     void endInlineMemberDoc()
 475     { forall(&OutputGenerator::endInlineMemberDoc); }
 476
 477     void startLabels()
 478     { forall(&OutputGenerator::startLabels); }
 479     void writeLabel(const char *l,bool isLast)
 480     { forall(&OutputGenerator::writeLabel,l,isLast); }
 481     void endLabels()
 482     { forall(&OutputGenerator::endLabels); }
 483
 484     void startFontClass(const char *c)
 485     { forall(&OutputGenerator::startFontClass,c); }
 486     void endFontClass()
 487     { forall(&OutputGenerator::endFontClass); }
 488     void writeCodeAnchor(const char *name)
 489     { forall(&OutputGenerator::writeCodeAnchor,name); }
 490     void setCurrentDoc(Definition *context,const char *anchor,bool isSourceFile)
 491     { forall(&OutputGenerator::setCurrentDoc,context,anchor,isSourceFile); }
 492     void addWord(const char *word,bool hiPriority)
 493     { forall(&OutputGenerator::addWord,word,hiPriority); }
 494
 495     void startPlainFile(const char *name)
 496     {
 497       QListIterator<OutputGenerator> it(m_outputs);
 498       OutputGenerator *og;
 499       for (;(og=it.current());++it)
 500       {
 501         if (og->isEnabled()) (og->startPlainFile)(name);
 502       }
 503     }
 504     void endPlainFile()
 505     {
 506       QListIterator<OutputGenerator> it(m_outputs);
 507       OutputGenerator *og;
 508       for (;(og=it.current());++it)
 509       {
 510         if (og->isEnabled()) (og->endPlainFile)();
 511       }
 512     }
 513
 514   private:
 515     void debug();
 516     void clear();
 517
 518     void forall(void (OutputGenerator::*func)());
 519     FORALLPROTO1(const char *);
 520     FORALLPROTO1(char);
 521     FORALLPROTO1(IndexSections);
 522     FORALLPROTO1(int);
 523     FORALLPROTO1(const DotClassGraph &);
 524     FORALLPROTO1(const DotInclDepGraph &);
 525     FORALLPROTO1(const DotCallGraph &);
 526     FORALLPROTO1(const DotGroupCollaboration &);
 527     FORALLPROTO1(const DotDirDeps &);
 528     FORALLPROTO1(const DotGfxHierarchyTable &);
 529     FORALLPROTO1(SectionTypes);
 530 #if defined(HAS_BOOL_TYPE) || defined(Q_HAS_BOOL_TYPE)
 531     FORALLPROTO1(bool);
 532     FORALLPROTO2(bool,int);
 533     FORALLPROTO2(bool,bool);
 534     FORALLPROTO2(const char *,bool);
 535     FORALLPROTO4(const char *,const char *,const char *,int);
 536 #endif
 537     FORALLPROTO2(int,bool);
 538     FORALLPROTO2(bool,const char *);
 539     FORALLPROTO2(ParamListTypes,const char *);
 540     FORALLPROTO2(const char *,const char *);
 541     FORALLPROTO2(const char *,int);
 542     FORALLPROTO2(const char *,SectionInfo::SectionType);
 543     FORALLPROTO3(bool,HighlightedItem,const char *);
 544     FORALLPROTO3(bool,bool,bool);
 545     FORALLPROTO3(const char *,const char *,bool);
 546     FORALLPROTO3(const char *,int,const char *);
 547     FORALLPROTO3(const char *,const char *,SectionInfo::SectionType);
 548     FORALLPROTO3(uchar,uchar,uchar);
 549     FORALLPROTO3(const char *,const char *,const char *);
 550     FORALLPROTO3(const ClassDiagram &,const char *,const char *);
 551     FORALLPROTO3(Definition*,const char *,bool);
 552     FORALLPROTO4(SectionTypes,const char *,const char *,const char *);
 553     FORALLPROTO4(const char *,const char *,const char *,const char *);
 554     FORALLPROTO4(const char *,const char *,const char *,bool);
 555     FORALLPROTO5(const char *,const char *,const char *,const char *,const char *);
 556     FORALLPROTO5(const char *,const char *,const char *,const char *,bool);
 557     FORALLPROTO6(const char *,const char *,const char *,const char *,const char *,const char *);
 558     FORALLPROTO6(const char *,const DocLinkInfo &,const char *,const char *,const SourceLinkInfo &,const SourceLinkInfo &);
 559     FORALLPROTO7(const char *,const char *,const char *,const char *,int,int,bool);
 560
 561     OutputList(const OutputList &ol);
 562     QList<OutputGenerator> m_outputs;
 563 };
 564
 565 #endif