Chameleon

Chameleon Svn Source Tree

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

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

Archive Download this file

Revision: 1322