diff -r 000000000000 -r 42188c7ea2d9 Orb/Doxygen/src/outputlist.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Orb/Doxygen/src/outputlist.h	Thu Jan 21 17:29:01 2010 +0000
@@ -0,0 +1,484 @@
+/******************************************************************************
+ *
+ * 
+ *
+ * Copyright (C) 1997-2008 by Dimitri van Heesch.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation under the terms of the GNU General Public License is hereby 
+ * granted. No representations are made about the suitability of this software 
+ * for any purpose. It is provided "as is" without express or implied warranty.
+ * See the GNU General Public License for more details.
+ *
+ * Documents produced by Doxygen are derivative works derived from the
+ * input used in their production; they are not affected by this license.
+ *
+ */
+
+#ifndef OUTPUTLIST_H
+#define OUTPUTLIST_H
+
+#include "qtbc.h"
+#include <qlist.h>
+#include "index.h" // for IndexSections
+#include "outputgen.h"
+
+#define FORALLPROTO1(arg1) \
+  void forall(void (OutputGenerator::*func)(arg1),arg1)
+#define FORALLPROTO2(arg1,arg2) \
+  void forall(void (OutputGenerator::*func)(arg1,arg2),arg1,arg2)
+#define FORALLPROTO3(arg1,arg2,arg3) \
+  void forall(void (OutputGenerator::*func)(arg1,arg2,arg3),arg1,arg2,arg3)
+#define FORALLPROTO4(arg1,arg2,arg3,arg4) \
+  void forall(void (OutputGenerator::*func)(arg1,arg2,arg3,arg4),arg1,arg2,arg3,arg4)
+#define FORALLPROTO5(arg1,arg2,arg3,arg4,arg5) \
+  void forall(void (OutputGenerator::*func)(arg1,arg2,arg3,arg4,arg5),arg1,arg2,arg3,arg4,arg5)
+  
+class ClassDiagram;
+class DotClassGraph;
+class DotDirDeps;
+class DotInclDepGraph;
+class DotGfxHierarchyTable;
+class SectionDict;
+class DotGroupCollaboration;
+
+class OutputList : public OutputDocInterface
+{
+  public:
+    OutputList(bool);
+    virtual ~OutputList();
+
+    void add(const OutputGenerator *);
+    
+    void disableAllBut(OutputGenerator::OutputType o);
+    void enableAll();
+    void disableAll();
+    void disable(OutputGenerator::OutputType o);
+    void enable(OutputGenerator::OutputType o);
+    bool isEnabled(OutputGenerator::OutputType o);
+    void pushGeneratorState();
+    void popGeneratorState();
+
+
+    //////////////////////////////////////////////////
+    // OutputDocInterface implementation
+    //////////////////////////////////////////////////
+
+    void parseDoc(const char *fileName,int startLine,
+                  Definition *ctx,MemberDef *md,const QCString &docStr,
+                  bool indexWords,bool isExample,const char *exampleName=0,
+                  bool singleLine=FALSE,bool linkFromIndex=FALSE);
+    void parseText(const QCString &textStr);
+    
+
+    void startIndexSection(IndexSections is)
+    { forall(&OutputGenerator::startIndexSection,is); }
+    void endIndexSection(IndexSections is)
+    { forall(&OutputGenerator::endIndexSection,is); }
+    void writePageLink(const char *name,bool first)
+    { forall(&OutputGenerator::writePageLink,name,first); }
+    void startProjectNumber()
+    { forall(&OutputGenerator::startProjectNumber); }
+    void endProjectNumber()
+    { forall(&OutputGenerator::endProjectNumber); }
+    void writeStyleInfo(int part) 
+    { forall(&OutputGenerator::writeStyleInfo,part); }
+    void startFile(const char *name,const char *manName,const char *title)
+    { forall(&OutputGenerator::startFile,name,manName,title); }
+    void writeFooter()
+    { forall(&OutputGenerator::writeFooter); }
+    void endFile() 
+    { forall(&OutputGenerator::endFile); }
+    void startTitleHead(const char *fileName) 
+    { forall(&OutputGenerator::startTitleHead,fileName); }
+    void endTitleHead(const char *fileName,const char *name)
+    { forall(&OutputGenerator::endTitleHead,fileName,name); }
+    void startTitle() 
+    { forall(&OutputGenerator::startTitle); }
+    void endTitle() 
+    { forall(&OutputGenerator::endTitle); }
+    //void newParagraph() 
+    //{ forall(&OutputGenerator::newParagraph); }
+    void startParagraph() 
+    { forall(&OutputGenerator::startParagraph); }
+    void endParagraph() 
+    { forall(&OutputGenerator::endParagraph); }
+    void writeString(const char *text) 
+    { forall(&OutputGenerator::writeString,text); }
+    void startIndexListItem() 
+    { forall(&OutputGenerator::startIndexListItem); }
+    void endIndexListItem() 
+    { forall(&OutputGenerator::endIndexListItem); }
+    void startIndexList() 
+    { forall(&OutputGenerator::startIndexList); }
+    void endIndexList() 
+    { forall(&OutputGenerator::endIndexList); }
+    void startIndexKey()
+    { forall(&OutputGenerator::startIndexKey); }
+    void endIndexKey()
+    { forall(&OutputGenerator::endIndexKey); }
+    void startIndexValue(bool b)
+    { forall(&OutputGenerator::startIndexValue,b); }
+    void endIndexValue(const char *name,bool b)
+    { forall(&OutputGenerator::endIndexValue,name,b); }
+    void startItemList() 
+    { forall(&OutputGenerator::startItemList); }
+    void endItemList() 
+    { forall(&OutputGenerator::endItemList); }
+    void startIndexItem(const char *ref,const char *file)
+    { forall(&OutputGenerator::startIndexItem,ref,file); }
+    void endIndexItem(const char *ref,const char *file)
+    { forall(&OutputGenerator::endIndexItem,ref,file); }
+    void docify(const char *s)
+    { forall(&OutputGenerator::docify,s); }
+    void codify(const char *s)
+    { forall(&OutputGenerator::codify,s); }
+    void writeObjectLink(const char *ref,const char *file,
+                         const char *anchor, const char *name)
+    { forall(&OutputGenerator::writeObjectLink,ref,file,anchor,name); }
+    void writeCodeLink(const char *ref,const char *file,
+                       const char *anchor,const char *name,
+                       const char *tooltip)
+    { forall(&OutputGenerator::writeCodeLink,ref,file,anchor,name,tooltip); }
+    void startTextLink(const char *file,const char *anchor)
+    { forall(&OutputGenerator::startTextLink,file,anchor); }
+    void endTextLink()
+    { forall(&OutputGenerator::endTextLink); }
+    void startHtmlLink(const char *url)
+    { forall(&OutputGenerator::startHtmlLink,url); }
+    void endHtmlLink()
+    { forall(&OutputGenerator::endHtmlLink); }
+    void writeStartAnnoItem(const char *type,const char *file, 
+                            const char *path,const char *name)
+    { forall(&OutputGenerator::writeStartAnnoItem,type,file,path,name); }
+    void writeEndAnnoItem(const char *name)
+    { forall(&OutputGenerator::writeEndAnnoItem,name); }
+    void startTypewriter() 
+    { forall(&OutputGenerator::startTypewriter); }
+    void endTypewriter() 
+    { forall(&OutputGenerator::endTypewriter); }
+    void startGroupHeader()
+    { forall(&OutputGenerator::startGroupHeader); }
+    void endGroupHeader()
+    { forall(&OutputGenerator::endGroupHeader); }
+    //void writeListItem() 
+    //{ forall(&OutputGenerator::writeListItem); }
+    void startItemListItem() 
+    { forall(&OutputGenerator::startItemListItem); }
+    void endItemListItem() 
+    { forall(&OutputGenerator::endItemListItem); }
+    void startMemberSections()
+    { forall(&OutputGenerator::startMemberSections); }
+    void endMemberSections()
+    { forall(&OutputGenerator::endMemberSections); }
+    void startMemberHeader()
+    { forall(&OutputGenerator::startMemberHeader); }
+    void endMemberHeader()
+    { forall(&OutputGenerator::endMemberHeader); }
+    void startMemberSubtitle()
+    { forall(&OutputGenerator::startMemberSubtitle); }
+    void endMemberSubtitle()
+    { forall(&OutputGenerator::endMemberSubtitle); }
+    void startMemberDocList() 
+    { forall(&OutputGenerator::startMemberDocList); }
+    void endMemberDocList() 
+    { forall(&OutputGenerator::endMemberDocList); }
+    void startMemberList() 
+    { forall(&OutputGenerator::startMemberList); }
+    void endMemberList() 
+    { forall(&OutputGenerator::endMemberList); }
+    void startAnonTypeScope(int i1) 
+    { forall(&OutputGenerator::startAnonTypeScope,i1); }
+    void endAnonTypeScope(int i1) 
+    { forall(&OutputGenerator::endAnonTypeScope,i1); }
+    void startMemberItem(int i1) 
+    { forall(&OutputGenerator::startMemberItem,i1); }
+    void endMemberItem() 
+    { forall(&OutputGenerator::endMemberItem); }
+    void startMemberTemplateParams() 
+    { forall(&OutputGenerator::startMemberTemplateParams); }
+    void endMemberTemplateParams() 
+    { forall(&OutputGenerator::endMemberTemplateParams); }
+    void startMemberGroupHeader(bool b) 
+    { forall(&OutputGenerator::startMemberGroupHeader,b); }
+    void endMemberGroupHeader()
+    { forall(&OutputGenerator::endMemberGroupHeader); }
+    void startMemberGroupDocs()
+    { forall(&OutputGenerator::startMemberGroupDocs); }
+    void endMemberGroupDocs()
+    { forall(&OutputGenerator::endMemberGroupDocs); }
+    void startMemberGroup()
+    { forall(&OutputGenerator::startMemberGroup); }
+    void endMemberGroup(bool last)
+    { forall(&OutputGenerator::endMemberGroup,last); }
+    void insertMemberAlign(bool templ=FALSE) 
+    { forall(&OutputGenerator::insertMemberAlign,templ); }
+    void writeRuler() 
+    { forall(&OutputGenerator::writeRuler); }
+    void writeAnchor(const char *fileName,const char *name)
+    { forall(&OutputGenerator::writeAnchor,fileName,name); }
+    void startCodeFragment() 
+    { forall(&OutputGenerator::startCodeFragment); }
+    void endCodeFragment() 
+    { forall(&OutputGenerator::endCodeFragment); }
+    void startCodeLine() 
+    { forall(&OutputGenerator::startCodeLine); }
+    void endCodeLine() 
+    { forall(&OutputGenerator::endCodeLine); }
+    void writeLineNumber(const char *ref,const char *file,const char *anchor,
+                         int lineNumber) 
+    { forall(&OutputGenerator::writeLineNumber,ref,file,anchor,lineNumber); }
+    void startEmphasis() 
+    { forall(&OutputGenerator::startEmphasis); }
+    void endEmphasis() 
+    { forall(&OutputGenerator::endEmphasis); }
+    void writeChar(char c)
+    { forall(&OutputGenerator::writeChar,c); }
+    void startMemberDoc(const char *clName,const char *memName,
+                        const char *anchor,const char *title)
+    { forall(&OutputGenerator::startMemberDoc,clName,memName,anchor,title); }
+    void endMemberDoc(bool hasArgs) 
+    { forall(&OutputGenerator::endMemberDoc,hasArgs); }
+    void startDoxyAnchor(const char *fName,const char *manName,
+                         const char *anchor, const char *name,
+                         const char *args)
+    { forall(&OutputGenerator::startDoxyAnchor,fName,manName,anchor,name,args); }
+    void endDoxyAnchor(const char *fn,const char *anchor)
+    { forall(&OutputGenerator::endDoxyAnchor,fn,anchor); }
+    void startCodeAnchor(const char *label)
+    { forall(&OutputGenerator::startCodeAnchor,label); }
+    void endCodeAnchor()
+    { forall(&OutputGenerator::endCodeAnchor); }
+    void writeLatexSpacing() 
+    { forall(&OutputGenerator::writeLatexSpacing); }
+    void startDescription() 
+    { forall(&OutputGenerator::startDescription); }
+    void endDescription() 
+    { forall(&OutputGenerator::endDescription); }
+    void startDescItem() 
+    { forall(&OutputGenerator::startDescItem); }
+    void endDescItem() 
+    { forall(&OutputGenerator::endDescItem); }
+    void startDescForItem() 
+    { forall(&OutputGenerator::startDescForItem); }
+    void endDescForItem() 
+    { forall(&OutputGenerator::endDescForItem); }
+    void startSubsection() 
+    { forall(&OutputGenerator::startSubsection); }
+    void endSubsection() 
+    { forall(&OutputGenerator::endSubsection); }
+    void startSubsubsection() 
+    { forall(&OutputGenerator::startSubsubsection); }
+    void endSubsubsection() 
+    { forall(&OutputGenerator::endSubsubsection); }
+    void startCenter() 
+    { forall(&OutputGenerator::startCenter); }
+    void endCenter() 
+    { forall(&OutputGenerator::endCenter); }
+    void startSmall() 
+    { forall(&OutputGenerator::startSmall); }
+    void endSmall() 
+    { forall(&OutputGenerator::endSmall); }
+    void lineBreak(const char *style=0) 
+    { forall(&OutputGenerator::lineBreak,style); }
+    void startBold() 
+    { forall(&OutputGenerator::startBold); }
+    void endBold() 
+    { forall(&OutputGenerator::endBold); }
+    void startMemberDescription() 
+    { forall(&OutputGenerator::startMemberDescription); }
+    void endMemberDescription() 
+    { forall(&OutputGenerator::endMemberDescription); }
+    void startSimpleSect(SectionTypes t,const char *file,const char *anchor,
+                         const char *title) 
+    { forall(&OutputGenerator::startSimpleSect,t,file,anchor,title); }
+    void endSimpleSect() 
+    { forall(&OutputGenerator::endSimpleSect); }
+    void startParamList(ParamListTypes t,const char *title) 
+    { forall(&OutputGenerator::startParamList,t,title); }
+    void endParamList() 
+    { forall(&OutputGenerator::endParamList); }
+    //void writeDescItem() 
+    //{ forall(&OutputGenerator::writeDescItem); }
+    void startIndent() 
+    { forall(&OutputGenerator::startIndent); }
+    void endIndent() 
+    { forall(&OutputGenerator::endIndent); }
+    void startSection(const char *lab,const char *title,SectionInfo::SectionType t)
+    { forall(&OutputGenerator::startSection,lab,title,t); }
+    void endSection(const char *lab,SectionInfo::SectionType t)
+    { forall(&OutputGenerator::endSection,lab,t); }
+    void addIndexItem(const char *s1,const char *s2)
+    { forall(&OutputGenerator::addIndexItem,s1,s2); }
+    void writeSynopsis() 
+    { forall(&OutputGenerator::writeSynopsis); }
+    void startClassDiagram()
+    { forall(&OutputGenerator::startClassDiagram); }
+    void endClassDiagram(const ClassDiagram &d,const char *f,const char *n)
+    { forall(&OutputGenerator::endClassDiagram,d,f,n); }
+    void startPageRef()
+    { forall(&OutputGenerator::startPageRef); }
+    void endPageRef(const char *c,const char *a)
+    { forall(&OutputGenerator::endPageRef,c,a); }
+    void startQuickIndices()
+    { forall(&OutputGenerator::startQuickIndices); }
+    void endQuickIndices()
+    { forall(&OutputGenerator::endQuickIndices); }
+    void writeQuickLinks(bool compact,HighlightedItem hli)
+    { forall(&OutputGenerator::writeQuickLinks,compact,hli); }
+    void startContents()
+    { forall(&OutputGenerator::startContents); }
+    void endContents()
+    { forall(&OutputGenerator::endContents); }
+    void writeNonBreakableSpace(int num)
+    { forall(&OutputGenerator::writeNonBreakableSpace,num); }
+    void startDescTable()
+    { forall(&OutputGenerator::startDescTable); }
+    void endDescTable()
+    { forall(&OutputGenerator::endDescTable); }
+    void startDescTableTitle()
+    { forall(&OutputGenerator::startDescTableTitle); }
+    void endDescTableTitle()
+    { forall(&OutputGenerator::endDescTableTitle); }
+    void startDescTableData()
+    { forall(&OutputGenerator::startDescTableData); }
+    void endDescTableData()
+    { forall(&OutputGenerator::endDescTableData); }
+    void startDotGraph()
+    { forall(&OutputGenerator::startDotGraph); }
+    void endDotGraph(const DotClassGraph &g)
+    { forall(&OutputGenerator::endDotGraph,g); }
+    void startInclDepGraph()
+    { forall(&OutputGenerator::startInclDepGraph); }
+    void endInclDepGraph(const DotInclDepGraph &g)
+    { forall(&OutputGenerator::endInclDepGraph,g); }
+    void startCallGraph()
+    { forall(&OutputGenerator::startCallGraph); }
+    void endCallGraph(const DotCallGraph &g)
+    { forall(&OutputGenerator::endCallGraph,g); }
+    void startDirDepGraph()
+    { forall(&OutputGenerator::startDirDepGraph); }
+    void endDirDepGraph(const DotDirDeps &g)
+    { forall(&OutputGenerator::endDirDepGraph,g); }
+    void startGroupCollaboration()
+    { forall(&OutputGenerator::startGroupCollaboration); }
+    void endGroupCollaboration(const DotGroupCollaboration &g)
+    { forall(&OutputGenerator::endGroupCollaboration,g); }
+    void writeGraphicalHierarchy(const DotGfxHierarchyTable &g)
+    { forall(&OutputGenerator::writeGraphicalHierarchy,g); }
+    void startTextBlock(bool dense=FALSE)
+    { forall(&OutputGenerator::startTextBlock,dense); }
+    void endTextBlock(bool paraBreak=FALSE)
+    { forall(&OutputGenerator::endTextBlock,paraBreak); }
+    void lastIndexPage()
+    { forall(&OutputGenerator::lastIndexPage); }
+    void startMemberDocPrefixItem()
+    { forall(&OutputGenerator::startMemberDocPrefixItem); }
+    void endMemberDocPrefixItem()
+    { forall(&OutputGenerator::endMemberDocPrefixItem); }
+    void startMemberDocName(bool align)
+    { forall(&OutputGenerator::startMemberDocName,align); }
+    void endMemberDocName()
+    { forall(&OutputGenerator::endMemberDocName); }
+    void startParameterType(bool first,const char *key)
+    { forall(&OutputGenerator::startParameterType,first,key); }
+    void endParameterType()
+    { forall(&OutputGenerator::endParameterType); }
+    void startParameterName(bool one)
+    { forall(&OutputGenerator::startParameterName,one); }
+    void endParameterName(bool last,bool one,bool bracket)
+    { forall(&OutputGenerator::endParameterName,last,one,bracket); }
+    void startParameterList(bool openBracket)
+    { forall(&OutputGenerator::startParameterList,openBracket); }
+    void endParameterList()
+    { forall(&OutputGenerator::endParameterList); }
+
+    void startConstraintList(const char *header) 
+    { forall(&OutputGenerator::startConstraintList,header); }
+    void startConstraintParam() 
+    { forall(&OutputGenerator::startConstraintParam); }
+    void endConstraintParam() 
+    { forall(&OutputGenerator::endConstraintParam); }
+    void startConstraintType()
+    { forall(&OutputGenerator::startConstraintType); }
+    void endConstraintType()
+    { forall(&OutputGenerator::endConstraintType); }
+    void startConstraintDocs()
+    { forall(&OutputGenerator::startConstraintDocs); }
+    void endConstraintDocs()
+    { forall(&OutputGenerator::endConstraintDocs); }
+    void endConstraintList()
+    { forall(&OutputGenerator::endConstraintList); }
+    void startFontClass(const char *c)
+    { forall(&OutputGenerator::startFontClass,c); }
+    void endFontClass()
+    { forall(&OutputGenerator::endFontClass); }
+    void writeCodeAnchor(const char *name)
+    { forall(&OutputGenerator::writeCodeAnchor,name); }
+    void startPlainFile(const char *name)
+    { 
+      OutputGenerator *og=outputs->first();
+      while (og)
+      {
+        if (og->isEnabled()) (og->startPlainFile)(name);
+        og=outputs->next();
+      }
+    }
+    void endPlainFile() 
+    { 
+      OutputGenerator *og=outputs->first();
+      while (og)
+      {
+        if (og->isEnabled()) (og->endPlainFile)();
+        og=outputs->next();
+      }
+    }
+    void linkableSymbol(int,const char *,Definition *,Definition *) {}
+
+
+
+  private:
+    void debug();
+    void clear();
+    
+    void forall(void (OutputGenerator::*func)());
+    FORALLPROTO1(const char *);
+    FORALLPROTO1(char);
+    FORALLPROTO1(IndexSections);
+    FORALLPROTO1(int);
+    FORALLPROTO1(const DotClassGraph &);
+    FORALLPROTO1(const DotInclDepGraph &);
+    FORALLPROTO1(const DotCallGraph &);
+    FORALLPROTO1(const DotGroupCollaboration &);
+    FORALLPROTO1(const DotDirDeps &);
+    FORALLPROTO1(const DotGfxHierarchyTable &);
+    FORALLPROTO1(SectionTypes);
+#if defined(HAS_BOOL_TYPE) || defined(Q_HAS_BOOL_TYPE)
+    FORALLPROTO1(bool);
+    FORALLPROTO2(bool,int);
+    FORALLPROTO2(bool,bool);
+    FORALLPROTO4(const char *,const char *,const char *,int);
+#endif
+    FORALLPROTO2(int,bool);
+    FORALLPROTO2(bool,HighlightedItem);
+    FORALLPROTO2(bool,const char *);
+    FORALLPROTO2(ParamListTypes,const char *);
+    FORALLPROTO2(const char *,const char *);
+    FORALLPROTO2(const char *,bool);
+    FORALLPROTO2(const char *,SectionInfo::SectionType);
+    FORALLPROTO3(bool,bool,bool);
+    FORALLPROTO3(const char *,const char *,bool);
+    FORALLPROTO3(const char *,const char *,SectionInfo::SectionType);
+    FORALLPROTO3(uchar,uchar,uchar);
+    FORALLPROTO3(const char *,const char *,const char *);
+    FORALLPROTO3(const ClassDiagram &,const char *,const char *);
+    FORALLPROTO4(SectionTypes,const char *,const char *,const char *);
+    FORALLPROTO4(const char *,const char *,const char *,const char *);
+    FORALLPROTO4(const char *,const char *,const char *,bool);
+    FORALLPROTO5(const char *,const char *,const char *,const char *,const char *);
+  
+    OutputList(const OutputList &ol);
+    QList<OutputGenerator> *outputs;
+};
+
+#endif