Chameleon

Chameleon Svn Source Tree

Root/branches/xZenu/src/util/doxygen/src/groupdef.cpp

Source at commit 1322 created 9 years 5 months ago.
By meklort, Add doxygen to utils folder
1/******************************************************************************
2 *
3 * $Id: groupdef.cpp,v 1.29 2001/03/19 19:27:40 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#include <ctype.h>
19#include <qregexp.h>
20#include "qtbc.h"
21#include "groupdef.h"
22#include "classdef.h"
23#include "filedef.h"
24#include "classlist.h"
25#include "outputlist.h"
26#include "namespacedef.h"
27#include "language.h"
28#include "util.h"
29#include "memberlist.h"
30#include "message.h"
31#include "membergroup.h"
32#include "doxygen.h"
33#include "pagedef.h"
34#include "docparser.h"
35#include "searchindex.h"
36#include "dot.h"
37#include "vhdldocgen.h"
38#include "layout.h"
39
40//---------------------------------------------------------------------------
41
42GroupDef::GroupDef(const char *df,int dl,const char *na,const char *t,
43 const char *refFileName) : Definition(df,dl,na)
44{
45 fileList = new FileList;
46 classSDict = new ClassSDict(17);
47 groupList = new GroupList;
48 namespaceSDict = new NamespaceSDict(17);
49 pageDict = new PageSDict(17);
50 exampleDict = new PageSDict(17);
51 dirList = new DirList;
52 allMemberNameInfoSDict = new MemberNameInfoSDict(17);
53 if (refFileName)
54 {
55 fileName=stripExtension(refFileName);
56 }
57 else
58 {
59 fileName = (QCString)"group_"+na;
60 }
61 setGroupTitle( t );
62 memberGroupSDict = new MemberGroupSDict;
63 memberGroupSDict->setAutoDelete(TRUE);
64
65 allMemberList = new MemberList(MemberList::allMembersList);
66
67 visited = 0;
68 groupScope = 0;
69}
70
71GroupDef::~GroupDef()
72{
73 delete fileList;
74 delete classSDict;
75 delete groupList;
76 delete namespaceSDict;
77 delete pageDict;
78 delete exampleDict;
79 delete allMemberList;
80 delete allMemberNameInfoSDict;
81 delete memberGroupSDict;
82 delete dirList;
83}
84
85void GroupDef::setGroupTitle( const char *t )
86{
87 if ( t && strlen(t) )
88 {
89 title = t;
90 titleSet = TRUE;
91 }
92 else
93 {
94 title = name();
95 title.at(0)=toupper(title.at(0));
96 titleSet = FALSE;
97 }
98}
99
100
101void GroupDef::distributeMemberGroupDocumentation()
102{
103 MemberGroupSDict::Iterator mgli(*memberGroupSDict);
104 MemberGroup *mg;
105 for (;(mg=mgli.current());++mgli)
106 {
107 mg->distributeMemberGroupDocumentation();
108 }
109}
110
111void GroupDef::findSectionsInDocumentation()
112{
113 docFindSections(documentation(),this,0,docFile());
114 MemberGroupSDict::Iterator mgli(*memberGroupSDict);
115 MemberGroup *mg;
116 for (;(mg=mgli.current());++mgli)
117 {
118 mg->findSectionsInDocumentation();
119 }
120
121 QListIterator<MemberList> mli(m_memberLists);
122 MemberList *ml;
123 for (mli.toFirst();(ml=mli.current());++mli)
124 {
125 if (ml->listType()&MemberList::declarationLists)
126 {
127 ml->findSectionsInDocumentation();
128 }
129 }
130}
131
132void GroupDef::addFile(const FileDef *def)
133{
134 static bool sortBriefDocs = Config_getBool("SORT_BRIEF_DOCS");
135 if (def->isHidden()) return;
136 if (sortBriefDocs)
137 fileList->inSort(def);
138 else
139 fileList->append(def);
140}
141
142bool GroupDef::addClass(const ClassDef *cd)
143{
144 static bool sortBriefDocs = Config_getBool("SORT_BRIEF_DOCS");
145 if (cd->isHidden()) return FALSE;
146 if (classSDict->find(cd->qualifiedName())==0)
147 {
148 //printf("addClass %s sort=%d\n",cd->qualifiedName().data(),sortBriefDocs);
149 if (sortBriefDocs)
150 classSDict->inSort(cd->qualifiedName(),cd);
151 else
152 classSDict->append(cd->qualifiedName(),cd);
153 return TRUE;
154 }
155 return FALSE;
156}
157
158bool GroupDef::addNamespace(const NamespaceDef *def)
159{
160 static bool sortBriefDocs = Config_getBool("SORT_BRIEF_DOCS");
161 if (def->isHidden()) return FALSE;
162 if (namespaceSDict->find(def->name())==0)
163 {
164 if (sortBriefDocs)
165 namespaceSDict->inSort(def->name(),def);
166 else
167 namespaceSDict->append(def->name(),def);
168 return TRUE;
169 }
170 return FALSE;
171}
172
173void GroupDef::addDir(const DirDef *def)
174{
175 if (def->isHidden()) return;
176 if (Config_getBool("SORT_BRIEF_DOCS"))
177 dirList->inSort(def);
178 else
179 dirList->append(def);
180}
181
182void GroupDef::addPage(PageDef *def)
183{
184 if (def->isHidden()) return;
185 //printf("Making page %s part of a group\n",def->name.data());
186 pageDict->append(def->name(),def);
187 def->makePartOfGroup(this);
188}
189
190void GroupDef::addExample(const PageDef *def)
191{
192 if (def->isHidden()) return;
193 exampleDict->append(def->name(),def);
194}
195
196
197void GroupDef::addMembersToMemberGroup()
198{
199 QListIterator<MemberList> mli(m_memberLists);
200 MemberList *ml;
201 for (mli.toFirst();(ml=mli.current());++mli)
202 {
203 if (ml->listType()&MemberList::declarationLists)
204 {
205 ::addMembersToMemberGroup(ml,&memberGroupSDict,this);
206 }
207 }
208
209 //printf("GroupDef::addMembersToMemberGroup() memberGroupList=%d\n",memberGroupList->count());
210 MemberGroupSDict::Iterator mgli(*memberGroupSDict);
211 MemberGroup *mg;
212 for (;(mg=mgli.current());++mgli)
213 {
214 mg->setInGroup(TRUE);
215 }
216}
217
218
219bool GroupDef::insertMember(MemberDef *md,bool docOnly)
220{
221 if (md->isHidden()) return FALSE;
222 //printf("GroupDef(%s)::insertMember(%s)\n", title.data(), md->name().data());
223 MemberNameInfo *mni=0;
224 if ((mni=(*allMemberNameInfoSDict)[md->name()]))
225 { // member with this name already found
226 MemberNameInfoIterator srcMnii(*mni);
227 MemberInfo *srcMi;
228 for ( ; (srcMi=srcMnii.current()) ; ++srcMnii )
229 {
230 MemberDef *srcMd = srcMi->memberDef;
231 if (srcMd==md) return FALSE; // already added before!
232
233 bool sameScope = srcMd->getOuterScope()==md->getOuterScope() || // same class or namespace
234 // both inside a file => definition and declaration do not have to be in the same file
235 (srcMd->getOuterScope()->definitionType()==Definition::TypeFile &&
236 md->getOuterScope()->definitionType()==Definition::TypeFile);
237
238 LockingPtr<ArgumentList> srcMdAl = srcMd->argumentList();
239 LockingPtr<ArgumentList> mdAl = md->argumentList();
240
241 if (srcMd->isFunction() && md->isFunction() &&
242 matchArguments2(srcMd->getOuterScope(),srcMd->getFileDef(),srcMdAl.pointer(),
243 md->getOuterScope(),md->getFileDef(),mdAl.pointer(),
244 TRUE
245 ) &&
246 sameScope
247 )
248 {
249 if (srcMd->getGroupAlias()==0)
250 {
251 md->setGroupAlias(srcMd);
252 }
253 else
254 {
255 md->setGroupAlias(srcMd->getGroupAlias());
256 }
257 return FALSE; // member is the same as one that is already added
258 }
259 }
260 mni->append(new MemberInfo(md,md->protection(),md->virtualness(),FALSE));
261 }
262 else
263 {
264 mni = new MemberNameInfo(md->name());
265 mni->append(new MemberInfo(md,md->protection(),md->virtualness(),FALSE));
266 allMemberNameInfoSDict->append(mni->memberName(),mni);
267 }
268 //printf("Added member!\n");
269 allMemberList->append(md);
270 switch(md->memberType())
271 {
272 case MemberDef::Variable:
273 if (!docOnly)
274 {
275 addMemberToList(MemberList::decVarMembers,md);
276 }
277 addMemberToList(MemberList::docVarMembers,md);
278 break;
279 case MemberDef::Function:
280 if (!docOnly)
281 {
282 addMemberToList(MemberList::decFuncMembers,md);
283 }
284 addMemberToList(MemberList::docFuncMembers,md);
285 break;
286 case MemberDef::Typedef:
287 if (!docOnly)
288 {
289 addMemberToList(MemberList::decTypedefMembers,md);
290 }
291 addMemberToList(MemberList::docTypedefMembers,md);
292 break;
293 case MemberDef::Enumeration:
294 if (!docOnly)
295 {
296 addMemberToList(MemberList::decEnumMembers,md);
297 }
298 addMemberToList(MemberList::docEnumMembers,md);
299 break;
300 case MemberDef::EnumValue:
301 if (!docOnly)
302 {
303 addMemberToList(MemberList::decEnumValMembers,md);
304 }
305 addMemberToList(MemberList::docEnumValMembers,md);
306 break;
307 case MemberDef::Define:
308 if (!docOnly)
309 {
310 addMemberToList(MemberList::decDefineMembers,md);
311 }
312 addMemberToList(MemberList::docDefineMembers,md);
313 break;
314 case MemberDef::Signal:
315 if (!docOnly)
316 {
317 addMemberToList(MemberList::decSignalMembers,md);
318 }
319 addMemberToList(MemberList::docSignalMembers,md);
320 break;
321 case MemberDef::Slot:
322 if (md->protection()==Public)
323 {
324 if (!docOnly)
325 {
326 addMemberToList(MemberList::decPubSlotMembers,md);
327 }
328 addMemberToList(MemberList::docPubSlotMembers,md);
329 }
330 else if (md->protection()==Protected)
331 {
332 if (!docOnly)
333 {
334 addMemberToList(MemberList::decProSlotMembers,md);
335 }
336 addMemberToList(MemberList::docProSlotMembers,md);
337 }
338 else
339 {
340 if (!docOnly)
341 {
342 addMemberToList(MemberList::decPriSlotMembers,md);
343 }
344 addMemberToList(MemberList::docPriSlotMembers,md);
345 }
346 break;
347 case MemberDef::Event:
348 if (!docOnly)
349 {
350 addMemberToList(MemberList::decEventMembers,md);
351 }
352 addMemberToList(MemberList::docEventMembers,md);
353 break;
354 case MemberDef::Property:
355 if (!docOnly)
356 {
357 addMemberToList(MemberList::decPropMembers,md);
358 }
359 addMemberToList(MemberList::docPropMembers,md);
360 break;
361 case MemberDef::Friend:
362 if (!docOnly)
363 {
364 addMemberToList(MemberList::decFriendMembers,md);
365 }
366 addMemberToList(MemberList::docFriendMembers,md);
367 break;
368 default:
369 err("GroupDef::insertMembers(): "
370 "member `%s' (typeid=%d) with scope `%s' inserted in group scope `%s'!\n",
371 md->name().data(),md->memberType(),
372 md->getClassDef() ? md->getClassDef()->name().data() : "",
373 name().data());
374 }
375 return TRUE;
376}
377
378void GroupDef::removeMember(MemberDef *md)
379{
380 // fprintf(stderr, "GroupDef(%s)::removeMember( %s )\n", title.data(), md->name().data());
381 MemberNameInfo *mni = allMemberNameInfoSDict->find(md->name());
382 if (mni)
383 {
384 MemberNameInfoIterator mnii(*mni);
385 while( mnii.current() )
386 {
387 if( mnii.current()->memberDef == md )
388 {
389mni->remove(mnii.current());
390 break;
391 }
392 ++mnii;
393 }
394 if( mni->isEmpty() )
395 {
396 allMemberNameInfoSDict->remove(md->name());
397 delete mni;
398 }
399
400 removeMemberFromList(MemberList::allMembersList,md);
401 switch(md->memberType())
402 {
403 case MemberDef::Variable:
404removeMemberFromList(MemberList::decVarMembers,md);
405 removeMemberFromList(MemberList::docVarMembers,md);
406 break;
407 case MemberDef::Function:
408 removeMemberFromList(MemberList::decFuncMembers,md);
409 removeMemberFromList(MemberList::docFuncMembers,md);
410 break;
411 case MemberDef::Typedef:
412 removeMemberFromList(MemberList::decTypedefMembers,md);
413 removeMemberFromList(MemberList::docTypedefMembers,md);
414 break;
415 case MemberDef::Enumeration:
416 removeMemberFromList(MemberList::decEnumMembers,md);
417 removeMemberFromList(MemberList::docEnumMembers,md);
418 break;
419 case MemberDef::EnumValue:
420 removeMemberFromList(MemberList::decEnumValMembers,md);
421 removeMemberFromList(MemberList::docEnumValMembers,md);
422 break;
423 case MemberDef::Define:
424 removeMemberFromList(MemberList::decDefineMembers,md);
425 removeMemberFromList(MemberList::docDefineMembers,md);
426 break;
427 case MemberDef::Signal:
428 removeMemberFromList(MemberList::decSignalMembers,md);
429 removeMemberFromList(MemberList::docSignalMembers,md);
430 break;
431 case MemberDef::Slot:
432 if (md->protection()==Public)
433 {
434 removeMemberFromList(MemberList::decPubSlotMembers,md);
435 removeMemberFromList(MemberList::docPubSlotMembers,md);
436 }
437 else if (md->protection()==Protected)
438 {
439 removeMemberFromList(MemberList::decProSlotMembers,md);
440 removeMemberFromList(MemberList::docProSlotMembers,md);
441 }
442 else
443 {
444 removeMemberFromList(MemberList::decPriSlotMembers,md);
445 removeMemberFromList(MemberList::docPriSlotMembers,md);
446 }
447 break;
448 case MemberDef::Event:
449 removeMemberFromList(MemberList::decEventMembers,md);
450 removeMemberFromList(MemberList::docEventMembers,md);
451 break;
452 case MemberDef::Property:
453 removeMemberFromList(MemberList::decPropMembers,md);
454 removeMemberFromList(MemberList::docPropMembers,md);
455 break;
456 case MemberDef::Friend:
457 removeMemberFromList(MemberList::decFriendMembers,md);
458 removeMemberFromList(MemberList::docFriendMembers,md);
459 break;
460 default:
461 err("GroupDef::removeMember(): unexpected member remove in file!\n");
462 }
463 }
464}
465
466bool GroupDef::containsGroup(const GroupDef *def)
467{
468 return this==def || groupList->find(def) >= 0;
469}
470
471void GroupDef::addGroup(const GroupDef *def)
472{
473 //printf("adding group `%s' to group `%s'\n",def->name().data(),name().data());
474 //if (Config_getBool("SORT_MEMBER_DOCS"))
475 // groupList->inSort(def);
476 //else
477 groupList->append(def);
478}
479
480bool GroupDef::isASubGroup() const
481{
482 LockingPtr<GroupList> groups = partOfGroups();
483 return groups!=0 && groups->count()!=0;
484}
485
486int GroupDef::countMembers() const
487{
488 return fileList->count()+
489 classSDict->count()+
490 namespaceSDict->count()+
491 groupList->count()+
492 allMemberList->count()+
493 pageDict->count()+
494 exampleDict->count();
495}
496
497/*! Compute the HTML anchor names for all members in the group */
498void GroupDef::computeAnchors()
499{
500 //printf("GroupDef::computeAnchors()\n");
501 setAnchors(0,'a',allMemberList);
502}
503
504void GroupDef::writeDetailedDescription(OutputList &ol,const QCString &title)
505{
506 if ((!briefDescription().isEmpty() && Config_getBool("REPEAT_BRIEF"))
507 || !documentation().isEmpty() || !inbodyDocumentation().isEmpty()
508 )
509 {
510 if (pageDict->count()!=countMembers()) // not only pages -> classical layout
511 {
512 ol.writeRuler();
513 ol.pushGeneratorState();
514 ol.disableAllBut(OutputGenerator::Html);
515 ol.writeAnchor(0,"details");
516 ol.popGeneratorState();
517 ol.startGroupHeader();
518 ol.parseText(title);
519 ol.endGroupHeader();
520 }
521
522 // repeat brief description
523 if (!briefDescription().isEmpty() && Config_getBool("REPEAT_BRIEF"))
524 {
525 ol.parseDoc(briefFile(),briefLine(),this,0,briefDescription(),FALSE,FALSE);
526 }
527 // write separator between brief and details
528 if (!briefDescription().isEmpty() && Config_getBool("REPEAT_BRIEF") &&
529 !documentation().isEmpty())
530 {
531 ol.pushGeneratorState();
532 ol.disable(OutputGenerator::Man);
533 ol.disable(OutputGenerator::RTF);
534 // ol.newParagraph(); // FIXME:PARA
535 ol.enableAll();
536 ol.disableAllBut(OutputGenerator::Man);
537 ol.writeString("\n\n");
538 ol.popGeneratorState();
539 }
540
541 // write detailed documentation
542 if (!documentation().isEmpty())
543 {
544 ol.parseDoc(docFile(),docLine(),this,0,documentation()+"\n",TRUE,FALSE);
545 }
546
547 // write inbody documentation
548 if (!inbodyDocumentation().isEmpty())
549 {
550 ol.parseDoc(inbodyFile(),inbodyLine(),this,0,inbodyDocumentation()+"\n",TRUE,FALSE);
551 }
552 }
553}
554
555void GroupDef::writeBriefDescription(OutputList &ol)
556{
557 if (!briefDescription().isEmpty())
558 {
559 ol.startParagraph();
560 ol.parseDoc(briefFile(),briefLine(),this,0,
561 briefDescription(),TRUE,FALSE,0,TRUE,FALSE);
562 ol.pushGeneratorState();
563 ol.disable(OutputGenerator::RTF);
564 ol.writeString(" \n");
565 ol.enable(OutputGenerator::RTF);
566
567 if (Config_getBool("REPEAT_BRIEF") ||
568 !documentation().isEmpty()
569 )
570 {
571 ol.disableAllBut(OutputGenerator::Html);
572 ol.startTextLink(0,"details");
573 ol.parseText(theTranslator->trMore());
574 ol.endTextLink();
575 }
576 ol.popGeneratorState();
577
578 //ol.pushGeneratorState();
579 //ol.disable(OutputGenerator::RTF);
580 //ol.newParagraph();
581 //ol.popGeneratorState();
582 ol.endParagraph();
583 }
584}
585
586void GroupDef::writeGroupGraph(OutputList &ol)
587{
588 if (Config_getBool("HAVE_DOT") /*&& Config_getBool("GROUP_GRAPHS")*/ )
589 {
590 DotGroupCollaboration graph(this);
591 if (!graph.isTrivial())
592 {
593 msg("Generating dependency graph for group %s\n",qualifiedName().data());
594 ol.pushGeneratorState();
595 ol.disable(OutputGenerator::Man);
596 //ol.startParagraph();
597 ol.startGroupCollaboration();
598 ol.parseText(theTranslator->trCollaborationDiagram(title));
599 ol.endGroupCollaboration(graph);
600 //ol.endParagraph();
601 ol.popGeneratorState();
602 }
603 }
604}
605
606void GroupDef::writeFiles(OutputList &ol,const QCString &title)
607{
608 // write list of files
609 if (fileList->count()>0)
610 {
611 ol.startMemberHeader("files");
612 ol.parseText(title);
613 ol.endMemberHeader();
614 ol.startMemberList();
615 FileDef *fd=fileList->first();
616 while (fd)
617 {
618 ol.startMemberItem(0);
619 ol.docify(theTranslator->trFile(FALSE,TRUE)+" ");
620 ol.insertMemberAlign();
621 ol.writeObjectLink(fd->getReference(),fd->getOutputFileBase(),0,fd->name());
622 if (!Config_getString("GENERATE_TAGFILE").isEmpty())
623 {
624 Doxygen::tagFile << " <file>" << convertToXML(fd->name()) << "</file>" << endl;
625 }
626 ol.endMemberItem();
627 if (!fd->briefDescription().isEmpty() && Config_getBool("BRIEF_MEMBER_DESC"))
628 {
629 ol.startParagraph();
630 ol.startMemberDescription();
631 ol.parseDoc(briefFile(),briefLine(),fd,0,fd->briefDescription(),FALSE,FALSE);
632 ol.endMemberDescription();
633 ol.endParagraph();
634 }
635 fd=fileList->next();
636 }
637 ol.endMemberList();
638 }
639}
640
641void GroupDef::writeNamespaces(OutputList &ol,const QCString &title)
642{
643 // write list of namespaces
644 namespaceSDict->writeDeclaration(ol,title);
645}
646
647void GroupDef::writeNestedGroups(OutputList &ol,const QCString &title)
648{
649 // write list of groups
650 if (groupList->count()>0)
651 {
652 ol.startMemberHeader("groups");
653 ol.parseText(title);
654 ol.endMemberHeader();
655 ol.startMemberList();
656 GroupDef *gd=groupList->first();
657 while (gd)
658 {
659 ol.startMemberItem(0);
660 //ol.docify(theTranslator->trGroup(FALSE,TRUE));
661 //ol.docify(" ");
662 ol.insertMemberAlign();
663 ol.writeObjectLink(gd->getReference(),gd->getOutputFileBase(),0,gd->groupTitle());
664 if (!Config_getString("GENERATE_TAGFILE").isEmpty())
665 {
666 Doxygen::tagFile << " <subgroup>" << convertToXML(gd->name()) << "</subgroup>" << endl;
667 }
668 ol.endMemberItem();
669 if (!gd->briefDescription().isEmpty() && Config_getBool("BRIEF_MEMBER_DESC"))
670 {
671 ol.startParagraph();
672 ol.startMemberDescription();
673 ol.parseDoc(briefFile(),briefLine(),gd,0,gd->briefDescription(),FALSE,FALSE);
674 ol.endMemberDescription();
675 ol.endParagraph();
676 }
677 gd=groupList->next();
678 }
679 ol.endMemberList();
680 }
681}
682
683void GroupDef::writeDirs(OutputList &ol,const QCString &title)
684{
685 // write list of directories
686 if (dirList->count()>0)
687 {
688 ol.startMemberHeader("dirs");
689 ol.parseText(title);
690 ol.endMemberHeader();
691 ol.startMemberList();
692 DirDef *dd=dirList->first();
693 while (dd)
694 {
695 ol.startMemberItem(0);
696 ol.parseText(theTranslator->trDir(FALSE,TRUE));
697 ol.insertMemberAlign();
698 ol.writeObjectLink(dd->getReference(),dd->getOutputFileBase(),0,dd->shortName());
699 ol.endMemberItem();
700 if (!Config_getString("GENERATE_TAGFILE").isEmpty())
701 {
702 Doxygen::tagFile << " <dir>" << convertToXML(dd->displayName()) << "</dir>" << endl;
703 }
704 if (!dd->briefDescription().isEmpty() && Config_getBool("BRIEF_MEMBER_DESC"))
705 {
706 ol.startParagraph();
707 ol.startMemberDescription();
708 ol.parseDoc(briefFile(),briefLine(),dd,0,dd->briefDescription(),FALSE,FALSE);
709 ol.endMemberDescription();
710 ol.endParagraph();
711 }
712 dd=dirList->next();
713 }
714
715 ol.endMemberList();
716 }
717}
718
719void GroupDef::writeClasses(OutputList &ol,const QCString &title)
720{
721 // write list of classes
722 classSDict->writeDeclaration(ol,0,title,FALSE);
723}
724
725void GroupDef::writeInlineClasses(OutputList &ol)
726{
727 classSDict->writeDocumentation(ol);
728}
729
730void GroupDef::writePageDocumentation(OutputList &ol)
731{
732 PageDef *pd=0;
733 PageSDict::Iterator pdi(*pageDict);
734 for (pdi.toFirst();(pd=pdi.current());++pdi)
735 {
736 if (!pd->isReference())
737 {
738 QCString pageName = pd->getOutputFileBase();
739
740 if (!Config_getString("GENERATE_TAGFILE").isEmpty())
741 {
742 Doxygen::tagFile << " <page>" << convertToXML(pageName) << "</page>" << endl;
743 }
744
745 SectionInfo *si=0;
746 if (!pd->title().isEmpty() && !pd->name().isEmpty() &&
747 (si=Doxygen::sectionDict[pd->name()])!=0)
748 {
749 ol.startSection(si->label,si->title,SectionInfo::Subsection);
750 ol.docify(si->title);
751 ol.endSection(si->label,SectionInfo::Subsection);
752 }
753 ol.startTextBlock();
754 ol.parseDoc(pd->docFile(),pd->docLine(),pd,0,pd->documentation()+pd->inbodyDocumentation(),TRUE,FALSE);
755 ol.endTextBlock();
756 }
757 }
758}
759
760void GroupDef::writeMemberGroups(OutputList &ol)
761{
762 /* write user defined member groups */
763 if (memberGroupSDict)
764 {
765 memberGroupSDict->sort();
766 /* write user defined member groups */
767 MemberGroupSDict::Iterator mgli(*memberGroupSDict);
768 MemberGroup *mg;
769 for (;(mg=mgli.current());++mgli)
770 {
771 mg->writeDeclarations(ol,0,0,0,this);
772 }
773 }
774}
775
776void GroupDef::startMemberDeclarations(OutputList &ol)
777{
778 ol.startMemberSections();
779}
780
781void GroupDef::endMemberDeclarations(OutputList &ol)
782{
783 ol.endMemberSections();
784}
785
786void GroupDef::startMemberDocumentation(OutputList &ol)
787{
788 //printf("** GroupDef::startMemberDocumentation()\n");
789 if (Config_getBool("SEPARATE_MEMBER_PAGES"))
790 {
791 ol.pushGeneratorState();
792 ol.disable(OutputGenerator::Html);
793 Doxygen::suppressDocWarnings = TRUE;
794 }
795}
796
797void GroupDef::endMemberDocumentation(OutputList &ol)
798{
799 //printf("** GroupDef::endMemberDocumentation()\n");
800 if (Config_getBool("SEPARATE_MEMBER_PAGES"))
801 {
802 ol.popGeneratorState();
803 Doxygen::suppressDocWarnings = FALSE;
804 }
805}
806
807void GroupDef::writeAuthorSection(OutputList &ol)
808{
809 // write Author section (Man only)
810 ol.pushGeneratorState();
811 ol.disableAllBut(OutputGenerator::Man);
812 ol.startGroupHeader();
813 ol.parseText(theTranslator->trAuthor(TRUE,TRUE));
814 ol.endGroupHeader();
815 ol.parseText(theTranslator->trGeneratedAutomatically(Config_getString("PROJECT_NAME")));
816 ol.popGeneratorState();
817}
818
819void GroupDef::writeSummaryLinks(OutputList &ol)
820{
821 ol.pushGeneratorState();
822 ol.disableAllBut(OutputGenerator::Html);
823 QListIterator<LayoutDocEntry> eli(
824 LayoutDocManager::instance().docEntries(LayoutDocManager::Group));
825 LayoutDocEntry *lde;
826 bool first=TRUE;
827 for (eli.toFirst();(lde=eli.current());++eli)
828 {
829 if ((lde->kind()==LayoutDocEntry::GroupClasses && classSDict->declVisible()) ||
830 (lde->kind()==LayoutDocEntry::GroupNamespaces && namespaceSDict->declVisible()) ||
831 (lde->kind()==LayoutDocEntry::GroupFiles && fileList->count()>0) ||
832 (lde->kind()==LayoutDocEntry::GroupNestedGroups && groupList->count()>0) ||
833 (lde->kind()==LayoutDocEntry::GroupDirs && dirList->count()>0)
834 )
835 {
836 LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
837 QCString label = lde->kind()==LayoutDocEntry::GroupClasses ? "nested-classes" :
838 lde->kind()==LayoutDocEntry::GroupNamespaces ? "namespaces" :
839 lde->kind()==LayoutDocEntry::GroupFiles ? "files" :
840 lde->kind()==LayoutDocEntry::GroupNestedGroups ? "groups" :
841 "dirs";
842 writeSummaryLink(ol,label,ls->title,first);
843 }
844 else if (lde->kind()==LayoutDocEntry::MemberDecl)
845 {
846 LayoutDocEntryMemberDecl *lmd = (LayoutDocEntryMemberDecl*)lde;
847 MemberList * ml = getMemberList(lmd->type);
848 if (ml && ml->declVisible())
849 {
850 writeSummaryLink(ol,ml->listTypeAsString(),lmd->title,first);
851 }
852 }
853 }
854 if (!first)
855 {
856 ol.writeString(" </div>\n");
857 }
858 ol.popGeneratorState();
859}
860
861void GroupDef::writeDocumentation(OutputList &ol)
862{
863 //static bool generateTreeView = Config_getBool("GENERATE_TREEVIEW");
864 ol.pushGeneratorState();
865 startFile(ol,getOutputFileBase(),name(),title);
866
867 ol.startHeaderSection();
868 writeSummaryLinks(ol);
869 ol.startTitleHead(getOutputFileBase());
870 ol.pushGeneratorState();
871 ol.disable(OutputGenerator::Man);
872 ol.parseText(title);
873 ol.popGeneratorState();
874 ol.endTitleHead(getOutputFileBase(),title);
875 addGroupListToTitle(ol,this);
876 ol.endHeaderSection();
877 ol.startContents();
878
879 if (Doxygen::searchIndex)
880 {
881 Doxygen::searchIndex->setCurrentDoc(title,getOutputFileBase());
882 static QRegExp we("[a-zA-Z_][-a-zA-Z_0-9]*");
883 int i=0,p=0,l=0;
884 while ((i=we.match(title,p,&l))!=-1) // foreach word in the title
885 {
886 Doxygen::searchIndex->addWord(title.mid(i,l),TRUE);
887 p=i+l;
888 }
889 }
890
891 Doxygen::indexList.addIndexItem(this,0,title);
892
893 if (!Config_getString("GENERATE_TAGFILE").isEmpty())
894 {
895 Doxygen::tagFile << " <compound kind=\"group\">" << endl;
896 Doxygen::tagFile << " <name>" << convertToXML(name()) << "</name>" << endl;
897 Doxygen::tagFile << " <title>" << convertToXML(title) << "</title>" << endl;
898 Doxygen::tagFile << " <filename>" << convertToXML(getOutputFileBase()) << Doxygen::htmlFileExtension << "</filename>" << endl;
899 }
900
901
902 //---------------------------------------- start flexible part -------------------------------
903
904 QListIterator<LayoutDocEntry> eli(
905 LayoutDocManager::instance().docEntries(LayoutDocManager::Group));
906 LayoutDocEntry *lde;
907 for (eli.toFirst();(lde=eli.current());++eli)
908 {
909 switch (lde->kind())
910 {
911 case LayoutDocEntry::BriefDesc:
912 writeBriefDescription(ol);
913 break;
914 case LayoutDocEntry::MemberDeclStart:
915 startMemberDeclarations(ol);
916 break;
917 case LayoutDocEntry::GroupClasses:
918 {
919 LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
920 writeClasses(ol,ls->title);
921 }
922 break;
923 case LayoutDocEntry::GroupInlineClasses:
924 {
925 writeInlineClasses(ol);
926 }
927 break;
928 case LayoutDocEntry::GroupNamespaces:
929 {
930 LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
931 writeNamespaces(ol,ls->title);
932 }
933 break;
934 case LayoutDocEntry::MemberGroups:
935 writeMemberGroups(ol);
936 break;
937 case LayoutDocEntry::MemberDecl:
938 {
939 LayoutDocEntryMemberDecl *lmd = (LayoutDocEntryMemberDecl*)lde;
940 writeMemberDeclarations(ol,lmd->type,lmd->title);
941 }
942 break;
943 case LayoutDocEntry::MemberDeclEnd:
944 endMemberDeclarations(ol);
945 break;
946 case LayoutDocEntry::DetailedDesc:
947 {
948 LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
949 writeDetailedDescription(ol,ls->title);
950 }
951 break;
952 case LayoutDocEntry::MemberDefStart:
953 startMemberDocumentation(ol);
954 break;
955 case LayoutDocEntry::MemberDef:
956 {
957 LayoutDocEntryMemberDef *lmd = (LayoutDocEntryMemberDef*)lde;
958 writeMemberDocumentation(ol,lmd->type,lmd->title);
959 }
960 break;
961 case LayoutDocEntry::MemberDefEnd:
962 endMemberDocumentation(ol);
963 break;
964 case LayoutDocEntry::GroupNestedGroups:
965 {
966 LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
967 writeNestedGroups(ol,ls->title);
968 }
969 break;
970 case LayoutDocEntry::GroupPageDocs:
971 writePageDocumentation(ol);
972 break;
973 case LayoutDocEntry::GroupDirs:
974 {
975 LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
976 writeDirs(ol,ls->title);
977 }
978 break;
979 case LayoutDocEntry::GroupFiles:
980 {
981 LayoutDocEntrySection *ls = (LayoutDocEntrySection*)lde;
982 writeFiles(ol,ls->title);
983 }
984 break;
985 case LayoutDocEntry::GroupGraph:
986 writeGroupGraph(ol);
987 break;
988 case LayoutDocEntry::AuthorSection:
989 writeAuthorSection(ol);
990 break;
991 case LayoutDocEntry::ClassIncludes:
992 case LayoutDocEntry::ClassInheritanceGraph:
993 case LayoutDocEntry::ClassNestedClasses:
994 case LayoutDocEntry::ClassCollaborationGraph:
995 case LayoutDocEntry::ClassAllMembersLink:
996 case LayoutDocEntry::ClassUsedFiles:
997 case LayoutDocEntry::NamespaceNestedNamespaces:
998 case LayoutDocEntry::NamespaceClasses:
999 case LayoutDocEntry::FileClasses:
1000 case LayoutDocEntry::FileNamespaces:
1001 case LayoutDocEntry::FileIncludes:
1002 case LayoutDocEntry::FileIncludeGraph:
1003 case LayoutDocEntry::FileIncludedByGraph:
1004 case LayoutDocEntry::FileSourceLink:
1005 case LayoutDocEntry::DirSubDirs:
1006 case LayoutDocEntry::DirFiles:
1007 case LayoutDocEntry::DirGraph:
1008 err("Internal inconsistency: member %d should not be part of "
1009 "LayoutDocManager::Group entry list\n",lde->kind());
1010 break;
1011 }
1012 }
1013
1014 //---------------------------------------- end flexible part -------------------------------
1015
1016 endFile(ol);
1017
1018 ol.popGeneratorState();
1019
1020 if (!Config_getString("GENERATE_TAGFILE").isEmpty())
1021 {
1022 writeDocAnchorsToTagFile();
1023 Doxygen::tagFile << " </compound>" << endl;
1024 }
1025
1026 if (Config_getBool("SEPARATE_MEMBER_PAGES"))
1027 {
1028 allMemberList->sort();
1029 writeMemberPages(ol);
1030 }
1031
1032}
1033
1034void GroupDef::writeMemberPages(OutputList &ol)
1035{
1036 ol.pushGeneratorState();
1037 ol.disableAllBut(OutputGenerator::Html);
1038
1039 QListIterator<MemberList> mli(m_memberLists);
1040 MemberList *ml;
1041 for (mli.toFirst();(ml=mli.current());++mli)
1042 {
1043 if (ml->listType()&MemberList::documentationLists)
1044 {
1045 ml->writeDocumentationPage(ol,name(),this);
1046 }
1047 }
1048
1049 ol.popGeneratorState();
1050}
1051
1052void GroupDef::writeQuickMemberLinks(OutputList &ol,MemberDef *currentMd) const
1053{
1054 static bool createSubDirs=Config_getBool("CREATE_SUBDIRS");
1055
1056 ol.writeString(" <div class=\"navtab\">\n");
1057 ol.writeString(" <table>\n");
1058
1059 MemberListIterator mli(*allMemberList);
1060 MemberDef *md;
1061 for (mli.toFirst();(md=mli.current());++mli)
1062 {
1063 if (md->getGroupDef()==this && md->isLinkable())
1064 {
1065 ol.writeString(" <tr><td class=\"navtab\">");
1066 if (md->isLinkableInProject())
1067 {
1068 if (md==currentMd) // selected item => highlight
1069 {
1070 ol.writeString("<a class=\"qindexHL\" ");
1071 }
1072 else
1073 {
1074 ol.writeString("<a class=\"qindex\" ");
1075 }
1076 ol.writeString("href=\"");
1077 if (createSubDirs) ol.writeString("../../");
1078 ol.writeString(md->getOutputFileBase()+Doxygen::htmlFileExtension+"#"+md->anchor());
1079 ol.writeString("\">");
1080 ol.writeString(md->localName());
1081 ol.writeString("</a>");
1082 }
1083 ol.writeString("</td></tr>\n");
1084 }
1085 }
1086
1087 ol.writeString(" </table>\n");
1088 ol.writeString(" </div>\n");
1089}
1090
1091
1092
1093//---- helper functions ------------------------------------------------------
1094
1095void addClassToGroups(Entry *root,ClassDef *cd)
1096{
1097 QListIterator<Grouping> gli(*root->groups);
1098 Grouping *g;
1099 for (;(g=gli.current());++gli)
1100 {
1101 GroupDef *gd=0;
1102 if (!g->groupname.isEmpty() && (gd=Doxygen::groupSDict->find(g->groupname)))
1103 {
1104 if (gd->addClass(cd))
1105 {
1106 cd->makePartOfGroup(gd);
1107 }
1108 //printf("Compound %s: in group %s\n",cd->name().data(),gd->groupTitle());
1109 }
1110 }
1111}
1112
1113void addNamespaceToGroups(Entry *root,NamespaceDef *nd)
1114{
1115 //printf("root->groups->count()=%d\n",root->groups->count());
1116 QListIterator<Grouping> gli(*root->groups);
1117 Grouping *g;
1118 for (;(g=gli.current());++gli)
1119 {
1120 GroupDef *gd=0;
1121 //printf("group `%s'\n",s->data());
1122 if (!g->groupname.isEmpty() && (gd=Doxygen::groupSDict->find(g->groupname)))
1123 {
1124 if (gd->addNamespace(nd)) nd->makePartOfGroup(gd);
1125 //printf("Namespace %s: in group %s\n",nd->name().data(),s->data());
1126 }
1127 }
1128}
1129
1130void addDirToGroups(Entry *root,DirDef *dd)
1131{
1132 //printf("*** root->groups->count()=%d\n",root->groups->count());
1133 QListIterator<Grouping> gli(*root->groups);
1134 Grouping *g;
1135 for (;(g=gli.current());++gli)
1136 {
1137 GroupDef *gd=0;
1138 //printf("group `%s'\n",g->groupname.data());
1139 if (!g->groupname.isEmpty() && (gd=Doxygen::groupSDict->find(g->groupname)))
1140 {
1141 gd->addDir(dd);
1142 dd->makePartOfGroup(gd);
1143 //printf("Dir %s: in group %s\n",dd->name().data(),g->groupname.data());
1144 }
1145 }
1146}
1147
1148void addGroupToGroups(Entry *root,GroupDef *subGroup)
1149{
1150 //printf("addGroupToGroups for %s groups=%d\n",root->name.data(),
1151 // root->groups?root->groups->count():-1);
1152 QListIterator<Grouping> gli(*root->groups);
1153 Grouping *g;
1154 for (;(g=gli.current());++gli)
1155 {
1156 GroupDef *gd=0;
1157 if (!g->groupname.isEmpty() && (gd=Doxygen::groupSDict->find(g->groupname)) &&
1158!gd->containsGroup(subGroup) )
1159 {
1160 gd->addGroup(subGroup);
1161 subGroup->makePartOfGroup(gd);
1162 }
1163 else if (gd==subGroup)
1164 {
1165 warn(root->fileName,root->startLine,"Trying to add group %s to itself!",
1166 gd->name().data());
1167 }
1168 }
1169}
1170
1171/*! Add a member to the group with the highest priority */
1172void addMemberToGroups(Entry *root,MemberDef *md)
1173{
1174// static bool inlineGroupedClasses = Config_getBool("INLINE_GROUPED_CLASSES");
1175// //printf("addMembersToGroups: %s: %s\n",md->name().data(),md->getClassDef()?md->getClassDef()->name().data():"<none>");
1176// if (inlineGroupedClasses && // member part of a grouped class?
1177// !md->getGroupDef() &&
1178// md->getClassDef() &&
1179// md->getClassDef()->partOfGroups()!=0 &&
1180// md->getClassDef()->partOfGroups()->count()>0)
1181// {
1182// GroupDef *gd = md->getClassDef()->partOfGroups()->at(0);
1183// //printf("-> add to group '%s'\n",gd->name().data());
1184// bool success = gd->insertMember(md);
1185// if (success)
1186// {
1187// md->setGroupDef(gd,
1188// Grouping::GROUPING_LOWEST,root->fileName,root->startLine,
1189// !root->doc.isEmpty());
1190// }
1191// }
1192// else // add if the member was explicitly added to a group
1193 {
1194
1195 //printf("addMemberToGroups: Root %p = %s, md %p=%s groups=%d\n",
1196 // root, root->name.data(), md, md->name().data(), root->groups->count() );
1197 QListIterator<Grouping> gli(*root->groups);
1198 Grouping *g;
1199
1200 // Search entry's group list for group with highest pri.
1201 Grouping::GroupPri_t pri = Grouping::GROUPING_LOWEST;
1202 GroupDef *fgd=0;
1203 for (;(g=gli.current());++gli)
1204 {
1205 GroupDef *gd=0;
1206 if (!g->groupname.isEmpty() &&
1207 (gd=Doxygen::groupSDict->find(g->groupname)) &&
1208 g->pri >= pri)
1209 {
1210 if (fgd && gd!=fgd && g->pri==pri)
1211 {
1212 warn(root->fileName.data(), root->startLine,
1213 "warning: Member %s found in multiple %s groups! "
1214 "The member will be put in group %s, and not in group %s",
1215 md->name().data(), Grouping::getGroupPriName( pri ),
1216 gd->name().data(), fgd->name().data()
1217 );
1218 }
1219
1220 fgd = gd;
1221 pri = g->pri;
1222 }
1223 }
1224 //printf("fgd=%p\n",fgd);
1225
1226 // put member into group defined by this entry?
1227 if (fgd)
1228 {
1229 GroupDef *mgd = md->getGroupDef();
1230 //printf("mgd=%p\n",mgd);
1231 bool insertit = FALSE;
1232 if (mgd==0)
1233 {
1234 insertit = TRUE;
1235 }
1236 else if (mgd!=fgd)
1237 {
1238 bool moveit = FALSE;
1239
1240 // move member from one group to another if
1241 // - the new one has a higher priority
1242 // - the new entry has the same priority, but with docs where the old one had no docs
1243 if (md->getGroupPri()<pri)
1244 {
1245 moveit = TRUE;
1246 }
1247 else
1248 {
1249 if (md->getGroupPri()==pri)
1250 {
1251 if (!root->doc.isEmpty() && !md->getGroupHasDocs())
1252 {
1253 moveit = TRUE;
1254 }
1255 else if (!root->doc.isEmpty() && md->getGroupHasDocs())
1256 {
1257 warn(md->getGroupFileName(),md->getGroupStartLine(),
1258 "warning: Member documentation for %s found several times in %s groups!\n"
1259 "%s:%d: The member will remain in group %s, and won't be put into group %s",
1260 md->name().data(), Grouping::getGroupPriName( pri ),
1261 root->fileName.data(), root->startLine,
1262 mgd->name().data(),
1263 fgd->name().data()
1264 );
1265 }
1266 }
1267 }
1268
1269 if (moveit)
1270 {
1271 //printf("removeMember\n");
1272 mgd->removeMember(md);
1273 insertit = TRUE;
1274 }
1275 }
1276
1277 if (insertit)
1278 {
1279 //printf("insertMember found at %s line %d\n",md->getDefFileName().data(),md->getDefLine());
1280 bool success = fgd->insertMember(md);
1281 if (success)
1282 {
1283 //printf("insertMember successful\n");
1284 md->setGroupDef(fgd,pri,root->fileName,root->startLine,
1285 !root->doc.isEmpty());
1286 ClassDef *cd = md->getClassDefOfAnonymousType();
1287 if (cd)
1288 {
1289 cd->setGroupDefForAllMembers(fgd,pri,root->fileName,root->startLine,root->doc.length() != 0);
1290 }
1291 }
1292 }
1293 }
1294 }
1295}
1296
1297
1298void addExampleToGroups(Entry *root,PageDef *eg)
1299{
1300 QListIterator<Grouping> gli(*root->groups);
1301 Grouping *g;
1302 for (;(g=gli.current());++gli)
1303 {
1304 GroupDef *gd=0;
1305 if (!g->groupname.isEmpty() && (gd=Doxygen::groupSDict->find(g->groupname)))
1306 {
1307 gd->addExample(eg);
1308 eg->makePartOfGroup(gd);
1309 //printf("Example %s: in group %s\n",eg->name().data(),s->data());
1310 }
1311 }
1312}
1313
1314QCString GroupDef::getOutputFileBase() const
1315{
1316 if (isReference())
1317 {
1318 return fileName;
1319 }
1320 else
1321 {
1322 return convertNameToFile(fileName);
1323 }
1324}
1325
1326void GroupDef::addListReferences()
1327{
1328 {
1329 LockingPtr< QList<ListItemInfo> > xrefItems = xrefListItems();
1330 addRefItem(xrefItems.pointer(),
1331 getOutputFileBase(),
1332 theTranslator->trGroup(TRUE,TRUE),
1333 getOutputFileBase(),name(),
1334 0
1335 );
1336 }
1337 MemberGroupSDict::Iterator mgli(*memberGroupSDict);
1338 MemberGroup *mg;
1339 for (;(mg=mgli.current());++mgli)
1340 {
1341 mg->addListReferences(this);
1342 }
1343 QListIterator<MemberList> mli(m_memberLists);
1344 MemberList *ml;
1345 for (mli.toFirst();(ml=mli.current());++mli)
1346 {
1347 if (ml->listType()&MemberList::documentationLists)
1348 {
1349 ml->addListReferences(this);
1350 }
1351 }
1352}
1353
1354MemberList *GroupDef::createMemberList(MemberList::ListType lt)
1355{
1356 m_memberLists.setAutoDelete(TRUE);
1357 QListIterator<MemberList> mli(m_memberLists);
1358 MemberList *ml;
1359 for (mli.toFirst();(ml=mli.current());++mli)
1360 {
1361 if (ml->listType()==lt)
1362 {
1363 return ml;
1364 }
1365 }
1366 // not found, create a new member list
1367 ml = new MemberList(lt);
1368 m_memberLists.append(ml);
1369 ml->setInGroup(TRUE);
1370 return ml;
1371}
1372
1373void GroupDef::addMemberToList(MemberList::ListType lt,MemberDef *md)
1374{
1375 static bool sortBriefDocs = Config_getBool("SORT_BRIEF_DOCS");
1376 static bool sortMemberDocs = Config_getBool("SORT_MEMBER_DOCS");
1377 MemberList *ml = createMemberList(lt);
1378 ml->setNeedsSorting(
1379 ((ml->listType()&MemberList::declarationLists) && sortBriefDocs) ||
1380 ((ml->listType()&MemberList::documentationLists) && sortMemberDocs));
1381 ml->append(md);
1382}
1383
1384void GroupDef::sortMemberLists()
1385{
1386 MemberList *ml = m_memberLists.first();
1387 while (ml)
1388 {
1389 if (ml->needsSorting()) { ml->sort(); ml->setNeedsSorting(FALSE); }
1390 ml = m_memberLists.next();
1391 }
1392}
1393
1394
1395MemberList *GroupDef::getMemberList(MemberList::ListType lt) const
1396{
1397 GroupDef *that = (GroupDef*)this;
1398 MemberList *ml = that->m_memberLists.first();
1399 while (ml)
1400 {
1401 if (ml->listType()==lt)
1402 {
1403 return ml;
1404 }
1405 ml = that->m_memberLists.next();
1406 }
1407 return 0;
1408}
1409
1410void GroupDef::writeMemberDeclarations(OutputList &ol,MemberList::ListType lt,const QCString &title)
1411{
1412 static bool optimizeVhdl = Config_getBool("OPTIMIZE_OUTPUT_VHDL");
1413
1414 MemberList * ml = getMemberList(lt);
1415 if (optimizeVhdl && ml)
1416 {
1417 VhdlDocGen::writeVhdlDeclarations(ml,ol,this,0,0);
1418 return;
1419 }
1420 if (ml)
1421 {
1422 ml->writeDeclarations(ol,0,0,0,this,title,0);
1423 }
1424}
1425
1426void GroupDef::writeMemberDocumentation(OutputList &ol,MemberList::ListType lt,const QCString &title)
1427{
1428 MemberList * ml = getMemberList(lt);
1429 if (ml) ml->writeDocumentation(ol,name(),this,title);
1430}
1431
1432void GroupDef::removeMemberFromList(MemberList::ListType lt,MemberDef *md)
1433{
1434 MemberList *ml = getMemberList(lt);
1435 if (ml) ml->remove(md);
1436}
1437
1438

Archive Download this file

Revision: 1322