1 /******************************************************************************
3 * $Id: outputlist.h,v 1.47 2001/03/19 19:27:41 root Exp $
5 * Copyright (C) 1997-2012 by Dimitri van Heesch.
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.
13 * Documents produced by Doxygen are derivative works derived from the
14 * input used in their production; they are not affected by this license.
23 #include "index.h" // for IndexSections
24 #include "outputgen.h"
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 #define FORALLPROTO6(arg1,arg2,arg3,arg4,arg5,arg6) \
37 void forall(void (OutputGenerator::*func)(arg1,arg2,arg3,arg4,arg5,arg6),arg1,arg2,arg3,arg4,arg5,arg6)
42 class DotInclDepGraph;
43 class DotGfxHierarchyTable;
45 class DotGroupCollaboration;
47 /** Class representing a list of output generators that are written to
50 class OutputList : public OutputDocInterface
54 virtual ~OutputList();
56 void add(const OutputGenerator *);
57 uint count() const { return outputs->count(); }
59 void disableAllBut(OutputGenerator::OutputType o);
62 void disable(OutputGenerator::OutputType o);
63 void enable(OutputGenerator::OutputType o);
64 bool isEnabled(OutputGenerator::OutputType o);
65 void pushGeneratorState();
66 void popGeneratorState();
69 //////////////////////////////////////////////////
70 // OutputDocInterface implementation
71 //////////////////////////////////////////////////
73 void parseDoc(const char *fileName,int startLine,
74 Definition *ctx,MemberDef *md,const QCString &docStr,
75 bool indexWords,bool isExample,const char *exampleName=0,
76 bool singleLine=FALSE,bool linkFromIndex=FALSE);
77 void parseText(const QCString &textStr);
80 void startIndexSection(IndexSections is)
81 { forall(&OutputGenerator::startIndexSection,is); }
82 void endIndexSection(IndexSections is)
83 { forall(&OutputGenerator::endIndexSection,is); }
84 void writePageLink(const char *name,bool first)
85 { forall(&OutputGenerator::writePageLink,name,first); }
86 void startProjectNumber()
87 { forall(&OutputGenerator::startProjectNumber); }
88 void endProjectNumber()
89 { forall(&OutputGenerator::endProjectNumber); }
90 void writeStyleInfo(int part)
91 { forall(&OutputGenerator::writeStyleInfo,part); }
92 void startFile(const char *name,const char *manName,const char *title)
93 { forall(&OutputGenerator::startFile,name,manName,title); }
94 void writeSearchInfo()
95 { forall(&OutputGenerator::writeSearchInfo); }
96 void writeFooter(const char *navPath)
97 { forall(&OutputGenerator::writeFooter,navPath); }
99 { forall(&OutputGenerator::endFile); }
100 void startTitleHead(const char *fileName)
101 { forall(&OutputGenerator::startTitleHead,fileName); }
102 void endTitleHead(const char *fileName,const char *name)
103 { forall(&OutputGenerator::endTitleHead,fileName,name); }
105 { forall(&OutputGenerator::startTitle); }
107 { forall(&OutputGenerator::endTitle); }
108 //void newParagraph()
109 //{ forall(&OutputGenerator::newParagraph); }
110 void startParagraph()
111 { forall(&OutputGenerator::startParagraph); }
113 { forall(&OutputGenerator::endParagraph); }
114 void writeString(const char *text)
115 { forall(&OutputGenerator::writeString,text); }
116 void startIndexListItem()
117 { forall(&OutputGenerator::startIndexListItem); }
118 void endIndexListItem()
119 { forall(&OutputGenerator::endIndexListItem); }
120 void startIndexList()
121 { forall(&OutputGenerator::startIndexList); }
123 { forall(&OutputGenerator::endIndexList); }
125 { forall(&OutputGenerator::startIndexKey); }
127 { forall(&OutputGenerator::endIndexKey); }
128 void startIndexValue(bool b)
129 { forall(&OutputGenerator::startIndexValue,b); }
130 void endIndexValue(const char *name,bool b)
131 { forall(&OutputGenerator::endIndexValue,name,b); }
133 { forall(&OutputGenerator::startItemList); }
135 { forall(&OutputGenerator::endItemList); }
136 void startIndexItem(const char *ref,const char *file)
137 { forall(&OutputGenerator::startIndexItem,ref,file); }
138 void endIndexItem(const char *ref,const char *file)
139 { forall(&OutputGenerator::endIndexItem,ref,file); }
140 void docify(const char *s)
141 { forall(&OutputGenerator::docify,s); }
142 void codify(const char *s)
143 { forall(&OutputGenerator::codify,s); }
144 void writeObjectLink(const char *ref,const char *file,
145 const char *anchor, const char *name)
146 { forall(&OutputGenerator::writeObjectLink,ref,file,anchor,name); }
147 void writeCodeLink(const char *ref,const char *file,
148 const char *anchor,const char *name,
150 { forall(&OutputGenerator::writeCodeLink,ref,file,anchor,name,tooltip); }
151 void startTextLink(const char *file,const char *anchor)
152 { forall(&OutputGenerator::startTextLink,file,anchor); }
154 { forall(&OutputGenerator::endTextLink); }
155 void startHtmlLink(const char *url)
156 { forall(&OutputGenerator::startHtmlLink,url); }
158 { forall(&OutputGenerator::endHtmlLink); }
159 void writeStartAnnoItem(const char *type,const char *file,
160 const char *path,const char *name)
161 { forall(&OutputGenerator::writeStartAnnoItem,type,file,path,name); }
162 void writeEndAnnoItem(const char *name)
163 { forall(&OutputGenerator::writeEndAnnoItem,name); }
164 void startTypewriter()
165 { forall(&OutputGenerator::startTypewriter); }
167 { forall(&OutputGenerator::endTypewriter); }
168 void startGroupHeader(int extraLevels=0)
169 { forall(&OutputGenerator::startGroupHeader,extraLevels); }
170 void endGroupHeader(int extraLevels=0)
171 { forall(&OutputGenerator::endGroupHeader,extraLevels); }
172 //void writeListItem()
173 //{ forall(&OutputGenerator::writeListItem); }
174 void startItemListItem()
175 { forall(&OutputGenerator::startItemListItem); }
176 void endItemListItem()
177 { forall(&OutputGenerator::endItemListItem); }
178 void startMemberSections()
179 { forall(&OutputGenerator::startMemberSections); }
180 void endMemberSections()
181 { forall(&OutputGenerator::endMemberSections); }
182 void startHeaderSection()
183 { forall(&OutputGenerator::startHeaderSection); }
184 void endHeaderSection()
185 { forall(&OutputGenerator::endHeaderSection); }
186 void startMemberHeader(const char *anchor)
187 { forall(&OutputGenerator::startMemberHeader,anchor); }
188 void endMemberHeader()
189 { forall(&OutputGenerator::endMemberHeader); }
190 void startMemberSubtitle()
191 { forall(&OutputGenerator::startMemberSubtitle); }
192 void endMemberSubtitle()
193 { forall(&OutputGenerator::endMemberSubtitle); }
194 void startMemberDocList()
195 { forall(&OutputGenerator::startMemberDocList); }
196 void endMemberDocList()
197 { forall(&OutputGenerator::endMemberDocList); }
198 void startMemberList()
199 { forall(&OutputGenerator::startMemberList); }
201 { forall(&OutputGenerator::endMemberList); }
202 void startInlineHeader()
203 { forall(&OutputGenerator::startInlineHeader); }
204 void endInlineHeader()
205 { forall(&OutputGenerator::endInlineHeader); }
206 void startAnonTypeScope(int i1)
207 { forall(&OutputGenerator::startAnonTypeScope,i1); }
208 void endAnonTypeScope(int i1)
209 { forall(&OutputGenerator::endAnonTypeScope,i1); }
210 void startMemberItem(const char *anchor,int i1,const char *id=0)
211 { forall(&OutputGenerator::startMemberItem,anchor,i1,id); }
213 { forall(&OutputGenerator::endMemberItem); }
214 void startMemberTemplateParams()
215 { forall(&OutputGenerator::startMemberTemplateParams); }
216 void endMemberTemplateParams(const char *anchor,const char *inheritId)
217 { forall(&OutputGenerator::endMemberTemplateParams,anchor,inheritId); }
218 void startMemberGroupHeader(bool b)
219 { forall(&OutputGenerator::startMemberGroupHeader,b); }
220 void endMemberGroupHeader()
221 { forall(&OutputGenerator::endMemberGroupHeader); }
222 void startMemberGroupDocs()
223 { forall(&OutputGenerator::startMemberGroupDocs); }
224 void endMemberGroupDocs()
225 { forall(&OutputGenerator::endMemberGroupDocs); }
226 void startMemberGroup()
227 { forall(&OutputGenerator::startMemberGroup); }
228 void endMemberGroup(bool last)
229 { forall(&OutputGenerator::endMemberGroup,last); }
230 void insertMemberAlign(bool templ=FALSE)
231 { forall(&OutputGenerator::insertMemberAlign,templ); }
233 { forall(&OutputGenerator::writeRuler); }
234 void writeAnchor(const char *fileName,const char *name)
235 { forall(&OutputGenerator::writeAnchor,fileName,name); }
236 void startCodeFragment()
237 { forall(&OutputGenerator::startCodeFragment); }
238 void endCodeFragment()
239 { forall(&OutputGenerator::endCodeFragment); }
240 void startCodeLine(bool hasLineNumbers)
241 { forall(&OutputGenerator::startCodeLine,hasLineNumbers); }
243 { forall(&OutputGenerator::endCodeLine); }
244 void writeLineNumber(const char *ref,const char *file,const char *anchor,
246 { forall(&OutputGenerator::writeLineNumber,ref,file,anchor,lineNumber); }
248 { forall(&OutputGenerator::startEmphasis); }
250 { forall(&OutputGenerator::endEmphasis); }
251 void writeChar(char c)
252 { forall(&OutputGenerator::writeChar,c); }
253 void startMemberDoc(const char *clName,const char *memName,
254 const char *anchor,const char *title,bool showInline)
255 { forall(&OutputGenerator::startMemberDoc,clName,memName,anchor,title,showInline); }
256 void endMemberDoc(bool hasArgs)
257 { forall(&OutputGenerator::endMemberDoc,hasArgs); }
258 void startDoxyAnchor(const char *fName,const char *manName,
259 const char *anchor, const char *name,
261 { forall(&OutputGenerator::startDoxyAnchor,fName,manName,anchor,name,args); }
262 void endDoxyAnchor(const char *fn,const char *anchor)
263 { forall(&OutputGenerator::endDoxyAnchor,fn,anchor); }
264 void startCodeAnchor(const char *label)
265 { forall(&OutputGenerator::startCodeAnchor,label); }
267 { forall(&OutputGenerator::endCodeAnchor); }
268 void writeLatexSpacing()
269 { forall(&OutputGenerator::writeLatexSpacing); }
270 void startDescription()
271 { forall(&OutputGenerator::startDescription); }
272 void endDescription()
273 { forall(&OutputGenerator::endDescription); }
275 { forall(&OutputGenerator::startDescItem); }
277 { forall(&OutputGenerator::endDescItem); }
278 void startDescForItem()
279 { forall(&OutputGenerator::startDescForItem); }
280 void endDescForItem()
281 { forall(&OutputGenerator::endDescForItem); }
282 void startSubsection()
283 { forall(&OutputGenerator::startSubsection); }
285 { forall(&OutputGenerator::endSubsection); }
286 void startSubsubsection()
287 { forall(&OutputGenerator::startSubsubsection); }
288 void endSubsubsection()
289 { forall(&OutputGenerator::endSubsubsection); }
291 { forall(&OutputGenerator::startCenter); }
293 { forall(&OutputGenerator::endCenter); }
295 { forall(&OutputGenerator::startSmall); }
297 { forall(&OutputGenerator::endSmall); }
298 void lineBreak(const char *style=0)
299 { forall(&OutputGenerator::lineBreak,style); }
301 { forall(&OutputGenerator::startBold); }
303 { forall(&OutputGenerator::endBold); }
304 void startMemberDescription(const char *anchor,const char *inheritId=0)
305 { forall(&OutputGenerator::startMemberDescription,anchor,inheritId); }
306 void endMemberDescription()
307 { forall(&OutputGenerator::endMemberDescription); }
308 void startMemberDeclaration()
309 { forall(&OutputGenerator::startMemberDeclaration); }
310 void endMemberDeclaration(const char *anchor,const char *inheritId)
311 { forall(&OutputGenerator::endMemberDeclaration,anchor,inheritId); }
312 void writeInheritedSectionTitle(const char *id, const char *ref,
313 const char *file, const char *anchor,
314 const char *title,const char *name)
315 { forall(&OutputGenerator::writeInheritedSectionTitle,id,ref,
316 file,anchor,title,name); }
317 void startSimpleSect(SectionTypes t,const char *file,const char *anchor,
319 { forall(&OutputGenerator::startSimpleSect,t,file,anchor,title); }
321 { forall(&OutputGenerator::endSimpleSect); }
322 void startParamList(ParamListTypes t,const char *title)
323 { forall(&OutputGenerator::startParamList,t,title); }
325 { forall(&OutputGenerator::endParamList); }
327 { forall(&OutputGenerator::startIndent); }
329 { forall(&OutputGenerator::endIndent); }
330 void startSection(const char *lab,const char *title,SectionInfo::SectionType t)
331 { forall(&OutputGenerator::startSection,lab,title,t); }
332 void endSection(const char *lab,SectionInfo::SectionType t)
333 { forall(&OutputGenerator::endSection,lab,t); }
334 void addIndexItem(const char *s1,const char *s2)
335 { forall(&OutputGenerator::addIndexItem,s1,s2); }
337 { forall(&OutputGenerator::writeSynopsis); }
338 void startClassDiagram()
339 { forall(&OutputGenerator::startClassDiagram); }
340 void endClassDiagram(const ClassDiagram &d,const char *f,const char *n)
341 { forall(&OutputGenerator::endClassDiagram,d,f,n); }
343 { forall(&OutputGenerator::startPageRef); }
344 void endPageRef(const char *c,const char *a)
345 { forall(&OutputGenerator::endPageRef,c,a); }
346 void startQuickIndices()
347 { forall(&OutputGenerator::startQuickIndices); }
348 void endQuickIndices()
349 { forall(&OutputGenerator::endQuickIndices); }
350 void writeSplitBar(const char *name)
351 { forall(&OutputGenerator::writeSplitBar,name); }
352 void writeNavigationPath(const char *s)
353 { forall(&OutputGenerator::writeNavigationPath,s); }
355 { forall(&OutputGenerator::writeLogo); }
356 void writeQuickLinks(bool compact,HighlightedItem hli,const char *file)
357 { forall(&OutputGenerator::writeQuickLinks,compact,hli,file); }
358 void writeSummaryLink(const char *file,const char *anchor,const char *title,bool first)
359 { forall(&OutputGenerator::writeSummaryLink,file,anchor,title,first); }
361 { forall(&OutputGenerator::startContents); }
363 { forall(&OutputGenerator::endContents); }
364 void writeNonBreakableSpace(int num)
365 { forall(&OutputGenerator::writeNonBreakableSpace,num); }
366 void startDescTable()
367 { forall(&OutputGenerator::startDescTable); }
369 { forall(&OutputGenerator::endDescTable); }
370 void startDescTableTitle()
371 { forall(&OutputGenerator::startDescTableTitle); }
372 void endDescTableTitle()
373 { forall(&OutputGenerator::endDescTableTitle); }
374 void startDescTableData()
375 { forall(&OutputGenerator::startDescTableData); }
376 void endDescTableData()
377 { forall(&OutputGenerator::endDescTableData); }
379 { forall(&OutputGenerator::startDotGraph); }
380 void endDotGraph(const DotClassGraph &g)
381 { forall(&OutputGenerator::endDotGraph,g); }
382 void startInclDepGraph()
383 { forall(&OutputGenerator::startInclDepGraph); }
384 void endInclDepGraph(const DotInclDepGraph &g)
385 { forall(&OutputGenerator::endInclDepGraph,g); }
386 void startCallGraph()
387 { forall(&OutputGenerator::startCallGraph); }
388 void endCallGraph(const DotCallGraph &g)
389 { forall(&OutputGenerator::endCallGraph,g); }
390 void startDirDepGraph()
391 { forall(&OutputGenerator::startDirDepGraph); }
392 void endDirDepGraph(const DotDirDeps &g)
393 { forall(&OutputGenerator::endDirDepGraph,g); }
394 void startGroupCollaboration()
395 { forall(&OutputGenerator::startGroupCollaboration); }
396 void endGroupCollaboration(const DotGroupCollaboration &g)
397 { forall(&OutputGenerator::endGroupCollaboration,g); }
398 void writeGraphicalHierarchy(const DotGfxHierarchyTable &g)
399 { forall(&OutputGenerator::writeGraphicalHierarchy,g); }
400 void startTextBlock(bool dense=FALSE)
401 { forall(&OutputGenerator::startTextBlock,dense); }
402 void endTextBlock(bool paraBreak=FALSE)
403 { forall(&OutputGenerator::endTextBlock,paraBreak); }
405 { forall(&OutputGenerator::lastIndexPage); }
406 void startMemberDocPrefixItem()
407 { forall(&OutputGenerator::startMemberDocPrefixItem); }
408 void endMemberDocPrefixItem()
409 { forall(&OutputGenerator::endMemberDocPrefixItem); }
410 void startMemberDocName(bool align)
411 { forall(&OutputGenerator::startMemberDocName,align); }
412 void endMemberDocName()
413 { forall(&OutputGenerator::endMemberDocName); }
414 void startParameterType(bool first,const char *key)
415 { forall(&OutputGenerator::startParameterType,first,key); }
416 void endParameterType()
417 { forall(&OutputGenerator::endParameterType); }
418 void startParameterName(bool one)
419 { forall(&OutputGenerator::startParameterName,one); }
420 void endParameterName(bool last,bool one,bool bracket)
421 { forall(&OutputGenerator::endParameterName,last,one,bracket); }
422 void startParameterList(bool openBracket)
423 { forall(&OutputGenerator::startParameterList,openBracket); }
424 void endParameterList()
425 { forall(&OutputGenerator::endParameterList); }
427 void startConstraintList(const char *header)
428 { forall(&OutputGenerator::startConstraintList,header); }
429 void startConstraintParam()
430 { forall(&OutputGenerator::startConstraintParam); }
431 void endConstraintParam()
432 { forall(&OutputGenerator::endConstraintParam); }
433 void startConstraintType()
434 { forall(&OutputGenerator::startConstraintType); }
435 void endConstraintType()
436 { forall(&OutputGenerator::endConstraintType); }
437 void startConstraintDocs()
438 { forall(&OutputGenerator::startConstraintDocs); }
439 void endConstraintDocs()
440 { forall(&OutputGenerator::endConstraintDocs); }
441 void endConstraintList()
442 { forall(&OutputGenerator::endConstraintList); }
444 void startMemberDocSimple()
445 { forall(&OutputGenerator::startMemberDocSimple); }
446 void endMemberDocSimple()
447 { forall(&OutputGenerator::endMemberDocSimple); }
448 void startInlineMemberType()
449 { forall(&OutputGenerator::startInlineMemberType); }
450 void endInlineMemberType()
451 { forall(&OutputGenerator::endInlineMemberType); }
452 void startInlineMemberName()
453 { forall(&OutputGenerator::startInlineMemberName); }
454 void endInlineMemberName()
455 { forall(&OutputGenerator::endInlineMemberName); }
456 void startInlineMemberDoc()
457 { forall(&OutputGenerator::startInlineMemberDoc); }
458 void endInlineMemberDoc()
459 { forall(&OutputGenerator::endInlineMemberDoc); }
462 { forall(&OutputGenerator::startLabels); }
463 void writeLabel(const char *l,bool isLast)
464 { forall(&OutputGenerator::writeLabel,l,isLast); }
466 { forall(&OutputGenerator::endLabels); }
468 void startFontClass(const char *c)
469 { forall(&OutputGenerator::startFontClass,c); }
471 { forall(&OutputGenerator::endFontClass); }
472 void writeCodeAnchor(const char *name)
473 { forall(&OutputGenerator::writeCodeAnchor,name); }
474 void startPlainFile(const char *name)
476 OutputGenerator *og=outputs->first();
479 if (og->isEnabled()) (og->startPlainFile)(name);
485 OutputGenerator *og=outputs->first();
488 if (og->isEnabled()) (og->endPlainFile)();
492 void linkableSymbol(int,const char *,Definition *,Definition *) {}
500 void forall(void (OutputGenerator::*func)());
501 FORALLPROTO1(const char *);
503 FORALLPROTO1(IndexSections);
505 FORALLPROTO1(const DotClassGraph &);
506 FORALLPROTO1(const DotInclDepGraph &);
507 FORALLPROTO1(const DotCallGraph &);
508 FORALLPROTO1(const DotGroupCollaboration &);
509 FORALLPROTO1(const DotDirDeps &);
510 FORALLPROTO1(const DotGfxHierarchyTable &);
511 FORALLPROTO1(SectionTypes);
512 #if defined(HAS_BOOL_TYPE) || defined(Q_HAS_BOOL_TYPE)
514 FORALLPROTO2(bool,int);
515 FORALLPROTO2(bool,bool);
516 FORALLPROTO2(const char *,bool);
517 FORALLPROTO4(const char *,const char *,const char *,int);
519 FORALLPROTO2(int,bool);
520 FORALLPROTO2(bool,const char *);
521 FORALLPROTO2(ParamListTypes,const char *);
522 FORALLPROTO2(const char *,const char *);
523 FORALLPROTO2(const char *,int);
524 FORALLPROTO2(const char *,SectionInfo::SectionType);
525 FORALLPROTO3(bool,HighlightedItem,const char *);
526 FORALLPROTO3(bool,bool,bool);
527 FORALLPROTO3(const char *,const char *,bool);
528 FORALLPROTO3(const char *,int,const char *);
529 FORALLPROTO3(const char *,const char *,SectionInfo::SectionType);
530 FORALLPROTO3(uchar,uchar,uchar);
531 FORALLPROTO3(const char *,const char *,const char *);
532 FORALLPROTO3(const ClassDiagram &,const char *,const char *);
533 FORALLPROTO4(SectionTypes,const char *,const char *,const char *);
534 FORALLPROTO4(const char *,const char *,const char *,const char *);
535 FORALLPROTO4(const char *,const char *,const char *,bool);
536 FORALLPROTO5(const char *,const char *,const char *,const char *,const char *);
537 FORALLPROTO5(const char *,const char *,const char *,const char *,bool);
538 FORALLPROTO6(const char *,const char *,const char *,const char *,const char *,const char *);
540 OutputList(const OutputList &ol);
541 QList<OutputGenerator> *outputs;