1 /******************************************************************************

     2  *

     3  * 

     4  *

     5  * Copyright (C) 1997-2008 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   

    37 class ClassDiagram;

    38 class DotClassGraph;

    39 class DotDirDeps;

    40 class DotInclDepGraph;

    41 class DotGfxHierarchyTable;

    42 class SectionDict;

    43 class DotGroupCollaboration;

    44 

    45 class 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()

   161     { forall(&OutputGenerator::startGroupHeader); }

   162     void endGroupHeader()

   163     { forall(&OutputGenerator::endGroupHeader); }

   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 startMemberHeader()

   175     { forall(&OutputGenerator::startMemberHeader); }

   176     void endMemberHeader()

   177     { forall(&OutputGenerator::endMemberHeader); }

   178     void startMemberSubtitle()

   179     { forall(&OutputGenerator::startMemberSubtitle); }

   180     void endMemberSubtitle()

   181     { forall(&OutputGenerator::endMemberSubtitle); }

   182     void startMemberDocList() 

   183     { forall(&OutputGenerator::startMemberDocList); }

   184     void endMemberDocList() 

   185     { forall(&OutputGenerator::endMemberDocList); }

   186     void startMemberList() 

   187     { forall(&OutputGenerator::startMemberList); }

   188     void endMemberList() 

   189     { forall(&OutputGenerator::endMemberList); }

   190     void startAnonTypeScope(int i1) 

   191     { forall(&OutputGenerator::startAnonTypeScope,i1); }

   192     void endAnonTypeScope(int i1) 

   193     { forall(&OutputGenerator::endAnonTypeScope,i1); }

   194     void startMemberItem(int i1) 

   195     { forall(&OutputGenerator::startMemberItem,i1); }

   196     void endMemberItem() 

   197     { forall(&OutputGenerator::endMemberItem); }

   198     void startMemberTemplateParams() 

   199     { forall(&OutputGenerator::startMemberTemplateParams); }

   200     void endMemberTemplateParams() 

   201     { forall(&OutputGenerator::endMemberTemplateParams); }

   202     void startMemberGroupHeader(bool b) 

   203     { forall(&OutputGenerator::startMemberGroupHeader,b); }

   204     void endMemberGroupHeader()

   205     { forall(&OutputGenerator::endMemberGroupHeader); }

   206     void startMemberGroupDocs()

   207     { forall(&OutputGenerator::startMemberGroupDocs); }

   208     void endMemberGroupDocs()

   209     { forall(&OutputGenerator::endMemberGroupDocs); }

   210     void startMemberGroup()

   211     { forall(&OutputGenerator::startMemberGroup); }

   212     void endMemberGroup(bool last)

   213     { forall(&OutputGenerator::endMemberGroup,last); }

   214     void insertMemberAlign(bool templ=FALSE) 

   215     { forall(&OutputGenerator::insertMemberAlign,templ); }

   216     void writeRuler() 

   217     { forall(&OutputGenerator::writeRuler); }

   218     void writeAnchor(const char *fileName,const char *name)

   219     { forall(&OutputGenerator::writeAnchor,fileName,name); }

   220     void startCodeFragment() 

   221     { forall(&OutputGenerator::startCodeFragment); }

   222     void endCodeFragment() 

   223     { forall(&OutputGenerator::endCodeFragment); }

   224     void startCodeLine() 

   225     { forall(&OutputGenerator::startCodeLine); }

   226     void endCodeLine() 

   227     { forall(&OutputGenerator::endCodeLine); }

   228     void writeLineNumber(const char *ref,const char *file,const char *anchor,

   229                          int lineNumber) 

   230     { forall(&OutputGenerator::writeLineNumber,ref,file,anchor,lineNumber); }

   231     void startEmphasis() 

   232     { forall(&OutputGenerator::startEmphasis); }

   233     void endEmphasis() 

   234     { forall(&OutputGenerator::endEmphasis); }

   235     void writeChar(char c)

   236     { forall(&OutputGenerator::writeChar,c); }

   237     void startMemberDoc(const char *clName,const char *memName,

   238                         const char *anchor,const char *title)

   239     { forall(&OutputGenerator::startMemberDoc,clName,memName,anchor,title); }

   240     void endMemberDoc(bool hasArgs) 

   241     { forall(&OutputGenerator::endMemberDoc,hasArgs); }

   242     void startDoxyAnchor(const char *fName,const char *manName,

   243                          const char *anchor, const char *name,

   244                          const char *args)

   245     { forall(&OutputGenerator::startDoxyAnchor,fName,manName,anchor,name,args); }

   246     void endDoxyAnchor(const char *fn,const char *anchor)

   247     { forall(&OutputGenerator::endDoxyAnchor,fn,anchor); }

   248     void startCodeAnchor(const char *label)

   249     { forall(&OutputGenerator::startCodeAnchor,label); }

   250     void endCodeAnchor()

   251     { forall(&OutputGenerator::endCodeAnchor); }

   252     void writeLatexSpacing() 

   253     { forall(&OutputGenerator::writeLatexSpacing); }

   254     void startDescription() 

   255     { forall(&OutputGenerator::startDescription); }

   256     void endDescription() 

   257     { forall(&OutputGenerator::endDescription); }

   258     void startDescItem() 

   259     { forall(&OutputGenerator::startDescItem); }

   260     void endDescItem() 

   261     { forall(&OutputGenerator::endDescItem); }

   262     void startDescForItem() 

   263     { forall(&OutputGenerator::startDescForItem); }

   264     void endDescForItem() 

   265     { forall(&OutputGenerator::endDescForItem); }

   266     void startSubsection() 

   267     { forall(&OutputGenerator::startSubsection); }

   268     void endSubsection() 

   269     { forall(&OutputGenerator::endSubsection); }

   270     void startSubsubsection() 

   271     { forall(&OutputGenerator::startSubsubsection); }

   272     void endSubsubsection() 

   273     { forall(&OutputGenerator::endSubsubsection); }

   274     void startCenter() 

   275     { forall(&OutputGenerator::startCenter); }

   276     void endCenter() 

   277     { forall(&OutputGenerator::endCenter); }

   278     void startSmall() 

   279     { forall(&OutputGenerator::startSmall); }

   280     void endSmall() 

   281     { forall(&OutputGenerator::endSmall); }

   282     void lineBreak(const char *style=0) 

   283     { forall(&OutputGenerator::lineBreak,style); }

   284     void startBold() 

   285     { forall(&OutputGenerator::startBold); }

   286     void endBold() 

   287     { forall(&OutputGenerator::endBold); }

   288     void startMemberDescription() 

   289     { forall(&OutputGenerator::startMemberDescription); }

   290     void endMemberDescription() 

   291     { forall(&OutputGenerator::endMemberDescription); }

   292     void startSimpleSect(SectionTypes t,const char *file,const char *anchor,

   293                          const char *title) 

   294     { forall(&OutputGenerator::startSimpleSect,t,file,anchor,title); }

   295     void endSimpleSect() 

   296     { forall(&OutputGenerator::endSimpleSect); }

   297     void startParamList(ParamListTypes t,const char *title) 

   298     { forall(&OutputGenerator::startParamList,t,title); }

   299     void endParamList() 

   300     { forall(&OutputGenerator::endParamList); }

   301     //void writeDescItem() 

   302     //{ forall(&OutputGenerator::writeDescItem); }

   303     void startIndent() 

   304     { forall(&OutputGenerator::startIndent); }

   305     void endIndent() 

   306     { forall(&OutputGenerator::endIndent); }

   307     void startSection(const char *lab,const char *title,SectionInfo::SectionType t)

   308     { forall(&OutputGenerator::startSection,lab,title,t); }

   309     void endSection(const char *lab,SectionInfo::SectionType t)

   310     { forall(&OutputGenerator::endSection,lab,t); }

   311     void addIndexItem(const char *s1,const char *s2)

   312     { forall(&OutputGenerator::addIndexItem,s1,s2); }

   313     void writeSynopsis() 

   314     { forall(&OutputGenerator::writeSynopsis); }

   315     void startClassDiagram()

   316     { forall(&OutputGenerator::startClassDiagram); }

   317     void endClassDiagram(const ClassDiagram &d,const char *f,const char *n)

   318     { forall(&OutputGenerator::endClassDiagram,d,f,n); }

   319     void startPageRef()

   320     { forall(&OutputGenerator::startPageRef); }

   321     void endPageRef(const char *c,const char *a)

   322     { forall(&OutputGenerator::endPageRef,c,a); }

   323     void startQuickIndices()

   324     { forall(&OutputGenerator::startQuickIndices); }

   325     void endQuickIndices()

   326     { forall(&OutputGenerator::endQuickIndices); }

   327     void writeQuickLinks(bool compact,HighlightedItem hli)

   328     { forall(&OutputGenerator::writeQuickLinks,compact,hli); }

   329     void startContents()

   330     { forall(&OutputGenerator::startContents); }

   331     void endContents()

   332     { forall(&OutputGenerator::endContents); }

   333     void writeNonBreakableSpace(int num)

   334     { forall(&OutputGenerator::writeNonBreakableSpace,num); }

   335     void startDescTable()

   336     { forall(&OutputGenerator::startDescTable); }

   337     void endDescTable()

   338     { forall(&OutputGenerator::endDescTable); }

   339     void startDescTableTitle()

   340     { forall(&OutputGenerator::startDescTableTitle); }

   341     void endDescTableTitle()

   342     { forall(&OutputGenerator::endDescTableTitle); }

   343     void startDescTableData()

   344     { forall(&OutputGenerator::startDescTableData); }

   345     void endDescTableData()

   346     { forall(&OutputGenerator::endDescTableData); }

   347     void startDotGraph()

   348     { forall(&OutputGenerator::startDotGraph); }

   349     void endDotGraph(const DotClassGraph &g)

   350     { forall(&OutputGenerator::endDotGraph,g); }

   351     void startInclDepGraph()

   352     { forall(&OutputGenerator::startInclDepGraph); }

   353     void endInclDepGraph(const DotInclDepGraph &g)

   354     { forall(&OutputGenerator::endInclDepGraph,g); }

   355     void startCallGraph()

   356     { forall(&OutputGenerator::startCallGraph); }

   357     void endCallGraph(const DotCallGraph &g)

   358     { forall(&OutputGenerator::endCallGraph,g); }

   359     void startDirDepGraph()

   360     { forall(&OutputGenerator::startDirDepGraph); }

   361     void endDirDepGraph(const DotDirDeps &g)

   362     { forall(&OutputGenerator::endDirDepGraph,g); }

   363     void startGroupCollaboration()

   364     { forall(&OutputGenerator::startGroupCollaboration); }

   365     void endGroupCollaboration(const DotGroupCollaboration &g)

   366     { forall(&OutputGenerator::endGroupCollaboration,g); }

   367     void writeGraphicalHierarchy(const DotGfxHierarchyTable &g)

   368     { forall(&OutputGenerator::writeGraphicalHierarchy,g); }

   369     void startTextBlock(bool dense=FALSE)

   370     { forall(&OutputGenerator::startTextBlock,dense); }

   371     void endTextBlock(bool paraBreak=FALSE)

   372     { forall(&OutputGenerator::endTextBlock,paraBreak); }

   373     void lastIndexPage()

   374     { forall(&OutputGenerator::lastIndexPage); }

   375     void startMemberDocPrefixItem()

   376     { forall(&OutputGenerator::startMemberDocPrefixItem); }

   377     void endMemberDocPrefixItem()

   378     { forall(&OutputGenerator::endMemberDocPrefixItem); }

   379     void startMemberDocName(bool align)

   380     { forall(&OutputGenerator::startMemberDocName,align); }

   381     void endMemberDocName()

   382     { forall(&OutputGenerator::endMemberDocName); }

   383     void startParameterType(bool first,const char *key)

   384     { forall(&OutputGenerator::startParameterType,first,key); }

   385     void endParameterType()

   386     { forall(&OutputGenerator::endParameterType); }

   387     void startParameterName(bool one)

   388     { forall(&OutputGenerator::startParameterName,one); }

   389     void endParameterName(bool last,bool one,bool bracket)

   390     { forall(&OutputGenerator::endParameterName,last,one,bracket); }

   391     void startParameterList(bool openBracket)

   392     { forall(&OutputGenerator::startParameterList,openBracket); }

   393     void endParameterList()

   394     { forall(&OutputGenerator::endParameterList); }

   395 

   396     void startConstraintList(const char *header) 

   397     { forall(&OutputGenerator::startConstraintList,header); }

   398     void startConstraintParam() 

   399     { forall(&OutputGenerator::startConstraintParam); }

   400     void endConstraintParam() 

   401     { forall(&OutputGenerator::endConstraintParam); }

   402     void startConstraintType()

   403     { forall(&OutputGenerator::startConstraintType); }

   404     void endConstraintType()

   405     { forall(&OutputGenerator::endConstraintType); }

   406     void startConstraintDocs()

   407     { forall(&OutputGenerator::startConstraintDocs); }

   408     void endConstraintDocs()

   409     { forall(&OutputGenerator::endConstraintDocs); }

   410     void endConstraintList()

   411     { forall(&OutputGenerator::endConstraintList); }

   412     void startFontClass(const char *c)

   413     { forall(&OutputGenerator::startFontClass,c); }

   414     void endFontClass()

   415     { forall(&OutputGenerator::endFontClass); }

   416     void writeCodeAnchor(const char *name)

   417     { forall(&OutputGenerator::writeCodeAnchor,name); }

   418     void startPlainFile(const char *name)

   419     { 

   420       OutputGenerator *og=outputs->first();

   421       while (og)

   422       {

   423         if (og->isEnabled()) (og->startPlainFile)(name);

   424         og=outputs->next();

   425       }

   426     }

   427     void endPlainFile() 

   428     { 

   429       OutputGenerator *og=outputs->first();

   430       while (og)

   431       {

   432         if (og->isEnabled()) (og->endPlainFile)();

   433         og=outputs->next();

   434       }

   435     }

   436     void linkableSymbol(int,const char *,Definition *,Definition *) {}

   437 

   438 

   439 

   440   private:

   441     void debug();

   442     void clear();

   443     

   444     void forall(void (OutputGenerator::*func)());

   445     FORALLPROTO1(const char *);

   446     FORALLPROTO1(char);

   447     FORALLPROTO1(IndexSections);

   448     FORALLPROTO1(int);

   449     FORALLPROTO1(const DotClassGraph &);

   450     FORALLPROTO1(const DotInclDepGraph &);

   451     FORALLPROTO1(const DotCallGraph &);

   452     FORALLPROTO1(const DotGroupCollaboration &);

   453     FORALLPROTO1(const DotDirDeps &);

   454     FORALLPROTO1(const DotGfxHierarchyTable &);

   455     FORALLPROTO1(SectionTypes);

   456 #if defined(HAS_BOOL_TYPE) || defined(Q_HAS_BOOL_TYPE)

   457     FORALLPROTO1(bool);

   458     FORALLPROTO2(bool,int);

   459     FORALLPROTO2(bool,bool);

   460     FORALLPROTO4(const char *,const char *,const char *,int);

   461 #endif

   462     FORALLPROTO2(int,bool);

   463     FORALLPROTO2(bool,HighlightedItem);

   464     FORALLPROTO2(bool,const char *);

   465     FORALLPROTO2(ParamListTypes,const char *);

   466     FORALLPROTO2(const char *,const char *);

   467     FORALLPROTO2(const char *,bool);

   468     FORALLPROTO2(const char *,SectionInfo::SectionType);

   469     FORALLPROTO3(bool,bool,bool);

   470     FORALLPROTO3(const char *,const char *,bool);

   471     FORALLPROTO3(const char *,const char *,SectionInfo::SectionType);

   472     FORALLPROTO3(uchar,uchar,uchar);

   473     FORALLPROTO3(const char *,const char *,const char *);

   474     FORALLPROTO3(const ClassDiagram &,const char *,const char *);

   475     FORALLPROTO4(SectionTypes,const char *,const char *,const char *);

   476     FORALLPROTO4(const char *,const char *,const char *,const char *);

   477     FORALLPROTO4(const char *,const char *,const char *,bool);

   478     FORALLPROTO5(const char *,const char *,const char *,const char *,const char *);

   479   

   480     OutputList(const OutputList &ol);

   481     QList<OutputGenerator> *outputs;

   482 };

   483 

   484 #endif