Doxygen
Loading...
Searching...
No Matches
index.cpp File Reference

This file contains functions for the various index pages. More...

#include <cstdlib>
#include <array>
#include <assert.h>
#include "message.h"
#include "index.h"
#include "indexlist.h"
#include "doxygen.h"
#include "config.h"
#include "filedef.h"
#include "outputlist.h"
#include "util.h"
#include "groupdef.h"
#include "language.h"
#include "htmlgen.h"
#include "htmlhelp.h"
#include "ftvhelp.h"
#include "dot.h"
#include "dotgfxhierarchytable.h"
#include "dotlegendgraph.h"
#include "pagedef.h"
#include "dirdef.h"
#include "vhdldocgen.h"
#include "layout.h"
#include "memberlist.h"
#include "classlist.h"
#include "namespacedef.h"
#include "filename.h"
#include "tooltip.h"
#include "utf8.h"
#include "portable.h"
#include "moduledef.h"
#include "sitemap.h"
Include dependency graph for index.cpp:

Go to the source code of this file.

Classes

struct  Index::Private
class  AlphaIndexTableCell
 Class representing a cell in the alphabetical class index. More...
struct  AnnotatedIndexContext
struct  CmhlInfo
 Helper class representing a class member in the navigation menu. More...
struct  FmhlInfo
 Helper class representing a file member in the navigation menu. More...
struct  NmhlInfo
 Helper class representing a namespace member in the navigation menu. More...
struct  MmhlInfo
 Helper class representing a module member in the navigation menu. More...

Macros

#define MAX_ITEMS_BEFORE_MULTIPAGE_INDEX   200
#define MAX_ITEMS_BEFORE_QUICK_INDEX   30

Typedefs

using UsedIndexLetters = std::set<std::string>

Functions

static int countClassHierarchy (ClassDef::CompoundType ct)
static void countFiles (int &htmlFiles, int &files)
static int countGroups ()
static int countDirs ()
static int countNamespaces ()
static int countConcepts ()
static int countAnnotatedClasses (int *cp, ClassDef::CompoundType ct)
static void countRelatedPages (int &docPages, int &indexPages)
static void MemberIndexMap_add (Index::MemberIndexMap &map, const std::string &letter, const MemberDef *md)
static void startIndexHierarchy (OutputList &ol, int level)
static void endIndexHierarchy (OutputList &ol, int level)
static void startQuickIndexList (OutputList &ol, bool letterTabs=FALSE)
static void endQuickIndexList (OutputList &ol)
static void startQuickIndexItem (OutputList &ol, const QCString &l, bool hl, bool, bool &first)
static void endQuickIndexItem (OutputList &ol)
void startTitle (OutputList &ol, const QCString &fileName, const DefinitionMutable *def)
void endTitle (OutputList &ol, const QCString &fileName, const QCString &name)
void startFile (OutputList &ol, const QCString &name, const QCString &manName, const QCString &title, HighlightedItem hli, bool additionalIndices, const QCString &altSidebarName, int hierarchyLevel, const QCString &allMembersFile)
void endFile (OutputList &ol, bool skipNavIndex, bool skipEndContents, const QCString &navPath)
void endFileWithNavPath (OutputList &ol, const DefinitionMutable *d, bool showPageNavigation)
static void writeMemberToIndex (const Definition *def, const MemberDef *md, bool addToIndex)
template<class T>
void addMembersToIndex (T *def, LayoutDocManager::LayoutPart part, const QCString &name, const QCString &anchor, bool addToIndex=TRUE, bool preventSeparateIndex=FALSE, const ConceptLinkedRefMap *concepts=nullptr)
static void writeClassTreeToOutput (OutputList &ol, const BaseClassList &bcl, int level, FTVHelp *ftv, bool addToIndex, ClassDefSet &visitedClasses)
static bool dirHasVisibleChildren (const DirDef *dd)
static void writeDirTreeNode (OutputList &ol, const DirDef *dd, int level, FTVHelp *ftv, bool addToIndex)
static void writeDirHierarchy (OutputList &ol, FTVHelp *ftv, bool addToIndex)
static void writeClassTreeForList (OutputList &ol, const ClassLinkedMap &cl, bool &started, FTVHelp *ftv, bool addToIndex, ClassDef::CompoundType ct, ClassDefSet &visitedClasses)
static void writeClassHierarchy (OutputList &ol, FTVHelp *ftv, bool addToIndex, ClassDef::CompoundType ct)
static int countClassesInTreeList (const ClassLinkedMap &cl, ClassDef::CompoundType ct)
static void writeHierarchicalIndex (OutputList &ol)
static void writeGraphicalClassHierarchy (OutputList &ol)
static void writeHierarchicalInterfaceIndex (OutputList &ol)
static void writeGraphicalInterfaceHierarchy (OutputList &ol)
static void writeHierarchicalExceptionIndex (OutputList &ol)
static void writeGraphicalExceptionHierarchy (OutputList &ol)
static void writeSingleFileIndex (OutputList &ol, const FileDef *fd)
static void writeDirIndex (OutputList &ol)
static void writeFileIndex (OutputList &ol)
template<typename Ptr>
const ClassDefget_pointer (const Ptr &p)
template<>
const ClassDefget_pointer (const ClassLinkedMap::Ptr &p)
template<>
const ClassDefget_pointer (const ClassLinkedRefMap::Ptr &p)
template<class ListType>
static void writeClassTree (const ListType &cl, FTVHelp *ftv, bool addToIndex, bool globalOnly, ClassDef::CompoundType ct)
static void writeNamespaceMembers (const NamespaceDef *nd, bool addToIndex)
static void writeModuleMembers (const ModuleDef *mod, bool addToIndex)
static void writeConceptList (const ConceptLinkedRefMap &concepts, FTVHelp *ftv, bool addToIndex)
static void writeNamespaceTree (const NamespaceLinkedRefMap &nsLinkedMap, FTVHelp *ftv, bool rootOnly, bool addToIndex)
static void writeNamespaceTreeElement (const NamespaceDef *nd, FTVHelp *ftv, bool rootOnly, bool addToIndex)
static void writeNamespaceTree (const NamespaceLinkedMap &nsLinkedMap, FTVHelp *ftv, bool rootOnly, bool addToIndex)
static void writeClassTreeInsideNamespace (const NamespaceLinkedRefMap &nsLinkedMap, FTVHelp *ftv, bool rootOnly, bool addToIndex, ClassDef::CompoundType ct)
static void writeClassTreeInsideNamespaceElement (const NamespaceDef *nd, FTVHelp *ftv, bool rootOnly, bool addToIndex, ClassDef::CompoundType ct)
static void writeClassTreeInsideNamespace (const NamespaceLinkedMap &nsLinkedMap, FTVHelp *ftv, bool rootOnly, bool addToIndex, ClassDef::CompoundType ct)
static void writeNamespaceIndex (OutputList &ol)
static void writeAnnotatedClassList (OutputList &ol, ClassDef::CompoundType ct)
bool isId1 (int c)
static QCString letterToLabel (const QCString &startLetter)
static void writeAlphabeticalClassList (OutputList &ol, ClassDef::CompoundType ct, int)
static void writeAlphabeticalIndex (OutputList &ol)
static void writeAlphabeticalInterfaceIndex (OutputList &ol)
static void writeAlphabeticalStructIndex (OutputList &ol)
static void writeAlphabeticalExceptionIndex (OutputList &ol)
static void writeAnnotatedIndexGeneric (OutputList &ol, const AnnotatedIndexContext ctx)
static void writeAnnotatedIndex (OutputList &ol)
static void writeAnnotatedInterfaceIndex (OutputList &ol)
static void writeAnnotatedStructIndex (OutputList &ol)
static void writeAnnotatedExceptionIndex (OutputList &ol)
static void writeClassLinkForMember (OutputList &ol, const MemberDef *md, const QCString &separator, QCString &prevClassName)
static void writeFileLinkForMember (OutputList &ol, const MemberDef *md, const QCString &separator, QCString &prevFileName)
static void writeNamespaceLinkForMember (OutputList &ol, const MemberDef *md, const QCString &separator, QCString &prevNamespaceName)
static void writeModuleLinkForMember (OutputList &ol, const MemberDef *md, const QCString &separator, QCString &prevModuleName)
static void writeMemberList (OutputList &ol, bool useSections, const std::string &page, const Index::MemberIndexMap &memberIndexMap, Definition::DefType type)
static void writeQuickMemberIndex (OutputList &ol, const Index::MemberIndexMap &map, const std::string &page, QCString fullName, bool multiPage)
static const CmhlInfogetCmhlInfo (size_t hl)
static void writeClassMemberIndexFiltered (OutputList &ol, ClassMemberHighlight::Enum hl)
static void writeClassMemberIndex (OutputList &ol)
static const FmhlInfogetFmhlInfo (size_t hl)
static void writeFileMemberIndexFiltered (OutputList &ol, FileMemberHighlight::Enum hl)
static void writeFileMemberIndex (OutputList &ol)
static const NmhlInfogetNmhlInfo (size_t hl)
static void writeNamespaceMemberIndexFiltered (OutputList &ol, NamespaceMemberHighlight::Enum hl)
static void writeNamespaceMemberIndex (OutputList &ol)
static const MmhlInfogetMmhlInfo (size_t hl)
static void writeModuleMemberIndexFiltered (OutputList &ol, ModuleMemberHighlight::Enum hl)
static void writeModuleMemberIndex (OutputList &ol)
static void writeExampleIndex (OutputList &ol)
static bool mainPageHasOwnTitle ()
static void writePages (PageDef *pd, FTVHelp *ftv)
static void writePageIndex (OutputList &ol)
void writeGraphInfo (OutputList &ol)
static void writeGroupTreeNode (OutputList &ol, const GroupDef *gd, int level, FTVHelp *ftv, bool addToIndex)
static void writeGroupHierarchy (OutputList &ol, FTVHelp *ftv, bool addToIndex)
static void writeTopicIndex (OutputList &ol)
static void writeModuleTreeNode (OutputList &ol, const ModuleDef *mod, FTVHelp *ftv, bool addToIndex)
static void writeModuleList (OutputList &ol, FTVHelp *ftv, bool addToIndex)
static void writeModuleIndex (OutputList &ol)
static void writeConceptTreeInsideNamespaceElement (const NamespaceDef *nd, FTVHelp *ftv, bool rootOnly, bool addToIndex)
static void writeConceptTreeInsideNamespace (const NamespaceLinkedRefMap &nsLinkedMap, FTVHelp *ftv, bool rootOnly, bool addToIndex)
static void writeConceptRootList (FTVHelp *ftv, bool addToIndex)
static void writeConceptIndex (OutputList &ol)
static void writeUserGroupStubPage (OutputList &ol, LayoutNavEntry *lne)
static void writeIndex (OutputList &ol)
static void writeIndexHierarchyEntries (OutputList &ol, const LayoutNavEntryList &entries)
static bool quickLinkVisible (LayoutNavEntry::Kind kind)
template<class T>
void renderMemberIndicesAsJs (std::ostream &t, std::function< std::size_t(std::size_t)> numDocumented, std::function< Index::MemberIndexMap(std::size_t)> getMemberList, const T *(*getInfo)(size_t hl), std::size_t total)
static bool renderQuickLinksAsJs (std::ostream &t, LayoutNavEntry *root, bool first)
static void writeMenuData ()
void writeIndexHierarchy (OutputList &ol)

Variables

const int maxItemsBeforeQuickIndex = MAX_ITEMS_BEFORE_QUICK_INDEX
static std::vector< bool > indexWritten

Detailed Description

This file contains functions for the various index pages.

Definition in file index.cpp.

Macro Definition Documentation

◆ MAX_ITEMS_BEFORE_MULTIPAGE_INDEX

◆ MAX_ITEMS_BEFORE_QUICK_INDEX

#define MAX_ITEMS_BEFORE_QUICK_INDEX   30

Definition at line 56 of file index.cpp.

Typedef Documentation

◆ UsedIndexLetters

using UsedIndexLetters = std::set<std::string>

Definition at line 2277 of file index.cpp.

Function Documentation

◆ addMembersToIndex()

template<class T>
void addMembersToIndex ( T * def,
LayoutDocManager::LayoutPart part,
const QCString & name,
const QCString & anchor,
bool addToIndex = TRUE,
bool preventSeparateIndex = FALSE,
const ConceptLinkedRefMap * concepts = nullptr )

Definition at line 528 of file index.cpp.

533{
534 int numClasses=0;
535 for (const auto &cd : def->getClasses())
536 {
537 if (cd->isLinkable()) numClasses++;
538 }
539 int numConcepts=0;
540 if (concepts)
541 {
542 for (const auto &cd : *concepts)
543 {
544 if (cd->isLinkable()) numConcepts++;
545 }
546 }
547 bool hasMembers = !def->getMemberLists().empty() || !def->getMemberGroups().empty() || (numClasses>0) || (numConcepts>0);
548 Doxygen::indexList->addContentsItem(hasMembers,name,
549 def->getReference(),def->getOutputFileBase(),anchor,
550 hasMembers && !preventSeparateIndex,
551 addToIndex,
552 def);
553 //printf("addMembersToIndex(def=%s hasMembers=%d numClasses=%d)\n",qPrint(def->name()),hasMembers,numClasses);
554 if (hasMembers || numClasses>0 || numConcepts>0)
555 {
556 Doxygen::indexList->incContentsDepth();
557 for (const auto &lde : LayoutDocManager::instance().docEntries(part))
558 {
559 auto kind = lde->kind();
560 if (kind==LayoutDocEntry::MemberDef)
561 {
562 const LayoutDocEntryMemberDef *lmd = dynamic_cast<const LayoutDocEntryMemberDef*>(lde.get());
563 if (lmd)
564 {
565 MemberList *ml = def->getMemberList(lmd->type);
566 if (ml)
567 {
568 for (const auto &md : *ml)
569 {
570 if (md->visibleInIndex())
571 {
572 writeMemberToIndex(def,md,addToIndex);
573 }
574 }
575 }
576 }
577 }
578 else if (kind==LayoutDocEntry::NamespaceClasses ||
579 kind==LayoutDocEntry::FileClasses ||
580 kind==LayoutDocEntry::ClassNestedClasses ||
581 kind==LayoutDocEntry::ModuleClasses
582 )
583 {
584 for (const auto &cd : def->getClasses())
585 {
586 if (cd->isLinkable() && (cd->partOfGroups().empty() || def->definitionType()==Definition::TypeGroup))
587 {
588 bool inlineSimpleStructs = Config_getBool(INLINE_SIMPLE_STRUCTS);
589 bool isNestedClass = def->definitionType()==Definition::TypeClass;
590 addMembersToIndex(cd,LayoutDocManager::Class,cd->displayName(lde->kind()==LayoutDocEntry::FileClasses),cd->anchor(),
591 addToIndex && (isNestedClass || (cd->isSimple() && inlineSimpleStructs)),
592 preventSeparateIndex || cd->isEmbeddedInOuterScope());
593 }
594 }
595 }
596 else if ((kind==LayoutDocEntry::FileConcepts || kind==LayoutDocEntry::ModuleConcepts) && concepts)
597 {
598 for (const auto &cd : *concepts)
599 {
600 if (cd->isLinkable() && (cd->partOfGroups().empty() || def->definitionType()==Definition::TypeGroup))
601 {
602 Doxygen::indexList->addContentsItem(false,cd->displayName(),
603 cd->getReference(),cd->getOutputFileBase(),QCString(),
604 addToIndex,
605 false,
606 cd);
607 }
608 }
609 }
610 }
611
612 Doxygen::indexList->decContentsDepth();
613 }
614}
static IndexList * indexList
Definition doxygen.h:134
static LayoutDocManager & instance()
Returns a reference to this singleton.
Definition layout.cpp:1435
A list of MemberDef objects as shown in documentation sections.
Definition memberlist.h:125
This is an alternative implementation of QCString.
Definition qcstring.h:101
#define Config_getBool(name)
Definition config.h:33
static void addMembersToIndex()
Definition doxygen.cpp:8092
static void writeMemberToIndex(const Definition *def, const MemberDef *md, bool addToIndex)
Definition index.cpp:468
Represents of a member definition list with configurable title.
Definition layout.h:132
MemberListType type
Definition layout.h:137

References addMembersToIndex(), Config_getBool, FALSE, Doxygen::indexList, LayoutDocManager::instance(), TRUE, LayoutDocEntryMemberDef::type, Definition::TypeClass, Definition::TypeGroup, and writeMemberToIndex().

◆ countAnnotatedClasses()

int countAnnotatedClasses ( int * cp,
ClassDef::CompoundType ct )
static

Definition at line 2128 of file index.cpp.

2129{
2130 bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
2131 int count=0;
2132 int countPrinted=0;
2133 for (const auto &cd : *Doxygen::classLinkedMap)
2134 {
2135 if (sliceOpt && cd->compoundType() != ct)
2136 {
2137 continue;
2138 }
2139 if (cd->isLinkableInProject() && !cd->isImplicitTemplateInstance())
2140 {
2141 if (!cd->isEmbeddedInOuterScope())
2142 {
2143 countPrinted++;
2144 }
2145 count++;
2146 }
2147 }
2148 *cp = countPrinted;
2149 return count;
2150}
static ClassLinkedMap * classLinkedMap
Definition doxygen.h:96

References Doxygen::classLinkedMap, and Config_getBool.

Referenced by Index::countDataStructures().

◆ countClassesInTreeList()

int countClassesInTreeList ( const ClassLinkedMap & cl,
ClassDef::CompoundType ct )
static

Definition at line 1090 of file index.cpp.

1091{
1092 bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
1093 int count=0;
1094 for (const auto &cd : cl)
1095 {
1096 if (sliceOpt && cd->compoundType() != ct)
1097 {
1098 continue;
1099 }
1100 if (!classHasVisibleRoot(cd->baseClasses())) // filter on root classes
1101 {
1102 if (cd->isVisibleInHierarchy()) // should it be visible
1103 {
1104 if (!cd->subClasses().empty()) // should have sub classes
1105 {
1106 count++;
1107 }
1108 }
1109 }
1110 }
1111 return count;
1112}
bool classHasVisibleRoot(const BaseClassList &bcl)

References classHasVisibleRoot(), and Config_getBool.

Referenced by countClassHierarchy().

◆ countClassHierarchy()

int countClassHierarchy ( ClassDef::CompoundType ct)
static

Definition at line 1114 of file index.cpp.

1115{
1116 int count=0;
1119 return count;
1120}
static ClassLinkedMap * hiddenClassLinkedMap
Definition doxygen.h:97
static int countClassesInTreeList(const ClassLinkedMap &cl, ClassDef::CompoundType ct)
Definition index.cpp:1090

References Doxygen::classLinkedMap, countClassesInTreeList(), and Doxygen::hiddenClassLinkedMap.

Referenced by Index::countDataStructures().

◆ countConcepts()

int countConcepts ( )
static

Definition at line 1709 of file index.cpp.

1710{
1711 int count=0;
1712 for (const auto &cd : *Doxygen::conceptLinkedMap)
1713 {
1714 if (cd->isLinkableInProject()) count++;
1715 }
1716 return count;
1717}
static ConceptLinkedMap * conceptLinkedMap
Definition doxygen.h:98

References Doxygen::conceptLinkedMap.

Referenced by Index::countDataStructures().

◆ countDirs()

int countDirs ( )
static

Definition at line 4047 of file index.cpp.

4048{
4049 int count=0;
4050 for (const auto &dd : *Doxygen::dirLinkedMap)
4051 {
4052 if (dd->isLinkableInProject())
4053 {
4054 count++;
4055 }
4056 }
4057 return count;
4058}
static DirLinkedMap * dirLinkedMap
Definition doxygen.h:129

References Doxygen::dirLinkedMap.

Referenced by Index::countDataStructures().

◆ countFiles()

void countFiles ( int & htmlFiles,
int & files )
static

Definition at line 1441 of file index.cpp.

1442{
1443 allFiles=0;
1444 docFiles=0;
1445 for (const auto &fn : *Doxygen::inputNameLinkedMap)
1446 {
1447 for (const auto &fd: *fn)
1448 {
1449 bool src = false;
1450 bool doc = fileVisibleInIndex(fd.get(),src);
1451 if (doc || src)
1452 {
1453 allFiles++;
1454 }
1455 if (doc)
1456 {
1457 docFiles++;
1458 }
1459 }
1460 }
1461}
static FileNameLinkedMap * inputNameLinkedMap
Definition doxygen.h:105
bool fileVisibleInIndex(const FileDef *fd, bool &genSourceFile)
Definition util.cpp:6606

References fileVisibleInIndex(), and Doxygen::inputNameLinkedMap.

Referenced by Index::countDataStructures().

◆ countGroups()

int countGroups ( )
static

Definition at line 4031 of file index.cpp.

4032{
4033 int count=0;
4034 for (const auto &gd : *Doxygen::groupLinkedMap)
4035 {
4036 if (!gd->isReference())
4037 {
4038 //gd->visited=FALSE;
4039 count++;
4040 }
4041 }
4042 return count;
4043}
static GroupLinkedMap * groupLinkedMap
Definition doxygen.h:114

References Doxygen::groupLinkedMap.

Referenced by Index::countDataStructures().

◆ countNamespaces()

int countNamespaces ( )
static

Definition at line 1698 of file index.cpp.

1699{
1700 int count=0;
1701 for (const auto &nd : *Doxygen::namespaceLinkedMap)
1702 {
1703 if (nd->isLinkableInProject()) count++;
1704 }
1705 return count;
1706}
static NamespaceLinkedMap * namespaceLinkedMap
Definition doxygen.h:115

References Doxygen::namespaceLinkedMap.

Referenced by Index::countDataStructures().

◆ countRelatedPages()

void countRelatedPages ( int & docPages,
int & indexPages )
static

Definition at line 3899 of file index.cpp.

3900{
3901 docPages=indexPages=0;
3902 for (const auto &pd : *Doxygen::pageLinkedMap)
3903 {
3904 if (pd->visibleInIndex() && !pd->hasParentPage())
3905 {
3906 indexPages++;
3907 }
3908 if (pd->documentedPage())
3909 {
3910 docPages++;
3911 }
3912 }
3913}
static PageLinkedMap * pageLinkedMap
Definition doxygen.h:100

References Doxygen::pageLinkedMap.

Referenced by Index::countDataStructures().

◆ dirHasVisibleChildren()

bool dirHasVisibleChildren ( const DirDef * dd)
static

Definition at line 728 of file index.cpp.

729{
730 if (dd->hasDocumentation()) return TRUE;
731
732 for (const auto &fd : dd->getFiles())
733 {
734 bool genSourceFile = false;
735 if (fileVisibleInIndex(fd,genSourceFile))
736 {
737 return TRUE;
738 }
739 if (genSourceFile)
740 {
741 return TRUE;
742 }
743 }
744
745 for(const auto &subdd : dd->subDirs())
746 {
747 if (dirHasVisibleChildren(subdd))
748 {
749 return TRUE;
750 }
751 }
752 return FALSE;
753}
virtual bool hasDocumentation() const =0
virtual const DirList & subDirs() const =0
virtual const FileList & getFiles() const =0
static bool dirHasVisibleChildren(const DirDef *dd)
Definition index.cpp:728
#define TRUE
Definition qcstring.h:37
#define FALSE
Definition qcstring.h:34

References dirHasVisibleChildren(), FALSE, fileVisibleInIndex(), DirDef::getFiles(), Definition::hasDocumentation(), DirDef::subDirs(), and TRUE.

Referenced by dirHasVisibleChildren(), and writeDirTreeNode().

◆ endFile()

void endFile ( OutputList & ol,
bool skipNavIndex,
bool skipEndContents,
const QCString & navPath )

Definition at line 427 of file index.cpp.

429{
430 bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
433 if (!skipNavIndex)
434 {
435 if (!skipEndContents) ol.endContents();
436 if (generateTreeView)
437 {
438 ol.writeString("</div><!-- doc-content -->\n");
439 ol.writeString("</div><!-- container -->\n");
440 }
441 }
442
443 ol.writeFooter(navPath); // write the footer
445 ol.endFile();
446}
void writeString(const QCString &text)
Definition outputlist.h:413
void endContents()
Definition outputlist.h:622
void endFile()
Definition outputlist.h:403
void pushGeneratorState()
void disableAllBut(OutputType o)
void popGeneratorState()
void writeFooter(const QCString &navPath)
Definition outputlist.h:401

References Config_getBool, OutputList::disableAllBut(), OutputList::endContents(), OutputList::endFile(), Html, OutputList::popGeneratorState(), OutputList::pushGeneratorState(), OutputList::writeFooter(), and OutputList::writeString().

Referenced by endFileWithNavPath(), generateExampleDocs(), writeAlphabeticalExceptionIndex(), writeAlphabeticalIndex(), writeAlphabeticalInterfaceIndex(), writeAlphabeticalStructIndex(), writeAnnotatedIndexGeneric(), writeClassMemberIndexFiltered(), writeConceptIndex(), writeDirIndex(), GroupDefImpl::writeDocumentation(), ModuleDefImpl::writeDocumentation(), PageDefImpl::writeDocumentation(), MemberList::writeDocumentationPage(), writeExampleIndex(), writeFileIndex(), writeFileMemberIndexFiltered(), writeGraphicalClassHierarchy(), writeGraphicalExceptionHierarchy(), writeGraphicalInterfaceHierarchy(), writeGraphInfo(), writeHierarchicalExceptionIndex(), writeHierarchicalIndex(), writeHierarchicalInterfaceIndex(), writeIndex(), ClassDefImpl::writeMemberList(), writeModuleIndex(), writeModuleMemberIndexFiltered(), writeNamespaceIndex(), writeNamespaceMemberIndexFiltered(), writePageIndex(), writeTopicIndex(), and writeUserGroupStubPage().

◆ endFileWithNavPath()

void endFileWithNavPath ( OutputList & ol,
const DefinitionMutable * d,
bool showPageNavigation )

Definition at line 448 of file index.cpp.

449{
450 bool generateTreeview = Config_getBool(GENERATE_TREEVIEW);
451 bool generateOutlinePanel = Config_getBool(PAGE_OUTLINE_PANEL);
452 QCString navPath;
453 if (generateTreeview)
454 {
457 ol.writeString("</div><!-- doc-content -->\n");
458 if (generateOutlinePanel && showPageNavigation) d->writePageNavigation(ol);
459 ol.writeString("</div><!-- container -->\n");
461 navPath = toDefinition(const_cast<DefinitionMutable*>(d))->navigationPathAsString();
462 }
463 endFile(ol,generateTreeview,TRUE,navPath);
464}
virtual QCString navigationPathAsString() const =0
virtual void writePageNavigation(OutputList &) const =0
Definition * toDefinition(DefinitionMutable *dm)
void endFile(OutputList &ol, bool skipNavIndex, bool skipEndContents, const QCString &navPath)
Definition index.cpp:427

References Config_getBool, OutputList::disableAllBut(), endFile(), Html, Definition::navigationPathAsString(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), toDefinition(), TRUE, DefinitionMutable::writePageNavigation(), and OutputList::writeString().

Referenced by ClassDefImpl::writeDocumentation(), ConceptDefImpl::writeDocumentation(), DirDefImpl::writeDocumentation(), DirRelation::writeDocumentation(), FileDefImpl::writeDocumentation(), NamespaceDefImpl::writeDocumentation(), PageDefImpl::writeDocumentation(), MemberList::writeDocumentationPage(), and FileDefImpl::writeSourceFooter().

◆ endIndexHierarchy()

◆ endQuickIndexItem()

void endQuickIndexItem ( OutputList & ol)
static

◆ endQuickIndexList()

void endQuickIndexList ( OutputList & ol)
static

◆ endTitle()

◆ get_pointer() [1/3]

template<>
const ClassDef * get_pointer ( const ClassLinkedMap::Ptr & p)

Definition at line 1722 of file index.cpp.

1722{ return p.get(); }

◆ get_pointer() [2/3]

template<>
const ClassDef * get_pointer ( const ClassLinkedRefMap::Ptr & p)

Definition at line 1723 of file index.cpp.

1723{ return p; }

◆ get_pointer() [3/3]

template<typename Ptr>
const ClassDef * get_pointer ( const Ptr & p)

Referenced by writeClassTree().

◆ getCmhlInfo()

const CmhlInfo * getCmhlInfo ( size_t hl)
static

Definition at line 3110 of file index.cpp.

3111{
3112 bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
3113 bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
3114 static CmhlInfo cmhlInfo[] =
3115 {
3116 CmhlInfo("functions", theTranslator->trAll()),
3117 CmhlInfo("functions_func",
3118 fortranOpt ? theTranslator->trSubprograms() :
3119 vhdlOpt ? theTranslator->trFunctionAndProc() :
3120 theTranslator->trFunctions()),
3121 CmhlInfo("functions_vars",theTranslator->trVariables()),
3122 CmhlInfo("functions_type",theTranslator->trTypedefs()),
3123 CmhlInfo("functions_enum",theTranslator->trEnumerations()),
3124 CmhlInfo("functions_eval",theTranslator->trEnumerationValues()),
3125 CmhlInfo("functions_prop",theTranslator->trProperties()),
3126 CmhlInfo("functions_evnt",theTranslator->trEvents()),
3127 CmhlInfo("functions_rela",theTranslator->trRelatedSymbols())
3128 };
3129 return &cmhlInfo[hl];
3130}
Translator * theTranslator
Definition language.cpp:71
Helper class representing a class member in the navigation menu.
Definition index.cpp:3104

References Config_getBool, and theTranslator.

Referenced by renderQuickLinksAsJs(), and writeClassMemberIndexFiltered().

◆ getFmhlInfo()

const FmhlInfo * getFmhlInfo ( size_t hl)
static

Definition at line 3298 of file index.cpp.

3299{
3300 bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
3301 bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
3302 bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
3303 static FmhlInfo fmhlInfo[] =
3304 {
3305 FmhlInfo("globals", theTranslator->trAll()),
3306 FmhlInfo("globals_func",
3307 fortranOpt ? theTranslator->trSubprograms() :
3308 vhdlOpt ? theTranslator->trFunctionAndProc() :
3309 theTranslator->trFunctions()),
3310 FmhlInfo("globals_vars",sliceOpt ? theTranslator->trConstants() : theTranslator->trVariables()),
3311 FmhlInfo("globals_type",theTranslator->trTypedefs()),
3312 FmhlInfo("globals_sequ",theTranslator->trSequences()),
3313 FmhlInfo("globals_dict",theTranslator->trDictionaries()),
3314 FmhlInfo("globals_enum",theTranslator->trEnumerations()),
3315 FmhlInfo("globals_eval",theTranslator->trEnumerationValues()),
3316 FmhlInfo("globals_defs",theTranslator->trDefines())
3317 };
3318 return &fmhlInfo[hl];
3319}
Helper class representing a file member in the navigation menu.
Definition index.cpp:3292

References Config_getBool, and theTranslator.

Referenced by renderQuickLinksAsJs(), and writeFileMemberIndexFiltered().

◆ getMmhlInfo()

const MmhlInfo * getMmhlInfo ( size_t hl)
static

Definition at line 3665 of file index.cpp.

3666{
3667 static MmhlInfo nmhlInfo[] =
3668 {
3669 MmhlInfo("modulemembers", theTranslator->trAll()),
3670 MmhlInfo("modulemembers_func",theTranslator->trFunctions()),
3671 MmhlInfo("modulemembers_vars",theTranslator->trVariables()),
3672 MmhlInfo("modulemembers_type",theTranslator->trTypedefs()),
3673 MmhlInfo("modulemembers_enum",theTranslator->trEnumerations()),
3674 MmhlInfo("modulemembers_eval",theTranslator->trEnumerationValues())
3675 };
3676 return &nmhlInfo[hl];
3677}
Helper class representing a module member in the navigation menu.
Definition index.cpp:3659

References theTranslator.

Referenced by renderQuickLinksAsJs(), and writeModuleMemberIndexFiltered().

◆ getNmhlInfo()

const NmhlInfo * getNmhlInfo ( size_t hl)
static

Definition at line 3480 of file index.cpp.

3481{
3482 bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
3483 bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
3484 bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
3485 static NmhlInfo nmhlInfo[] =
3486 {
3487 NmhlInfo("namespacemembers", theTranslator->trAll()),
3488 NmhlInfo("namespacemembers_func",
3489 fortranOpt ? theTranslator->trSubprograms() :
3490 vhdlOpt ? theTranslator->trFunctionAndProc() :
3491 theTranslator->trFunctions()),
3492 NmhlInfo("namespacemembers_vars",sliceOpt ? theTranslator->trConstants() : theTranslator->trVariables()),
3493 NmhlInfo("namespacemembers_type",theTranslator->trTypedefs()),
3494 NmhlInfo("namespacemembers_sequ",theTranslator->trSequences()),
3495 NmhlInfo("namespacemembers_dict",theTranslator->trDictionaries()),
3496 NmhlInfo("namespacemembers_enum",theTranslator->trEnumerations()),
3497 NmhlInfo("namespacemembers_eval",theTranslator->trEnumerationValues())
3498 };
3499 return &nmhlInfo[hl];
3500}
Helper class representing a namespace member in the navigation menu.
Definition index.cpp:3474

References Config_getBool, and theTranslator.

Referenced by renderQuickLinksAsJs(), and writeNamespaceMemberIndexFiltered().

◆ isId1()

bool isId1 ( int c)
inline

Definition at line 2226 of file index.cpp.

2227{
2228 return (c<127 && c>31); // printable ASCII character
2229}

Referenced by letterToLabel().

◆ letterToLabel()

QCString letterToLabel ( const QCString & startLetter)
static

Definition at line 2231 of file index.cpp.

2232{
2233 if (startLetter.isEmpty()) return startLetter;
2234 const char *p = startLetter.data();
2235 char c = *p;
2236 QCString result;
2237 if (isId1(c))
2238 {
2239 result+=c;
2240 }
2241 else
2242 {
2243 result="0x";
2244 const char hex[]="0123456789abcdef";
2245 while ((c=*p++))
2246 {
2247 result+=hex[static_cast<unsigned char>(c)>>4];
2248 result+=hex[static_cast<unsigned char>(c)&0xf];
2249 }
2250 }
2251 return result;
2252}
bool isEmpty() const
Returns TRUE iff the string is empty.
Definition qcstring.h:150
const char * data() const
Returns a pointer to the contents of the string in the form of a 0-terminated C string.
Definition qcstring.h:159
static constexpr auto hex
bool isId1(int c)
Definition index.cpp:2226

References QCString::data(), hex, QCString::isEmpty(), and isId1().

Referenced by renderMemberIndicesAsJs(), writeAlphabeticalClassList(), writeClassMemberIndexFiltered(), writeFileMemberIndexFiltered(), writeMemberList(), writeModuleMemberIndexFiltered(), writeNamespaceMemberIndexFiltered(), and writeQuickMemberIndex().

◆ mainPageHasOwnTitle()

bool mainPageHasOwnTitle ( )
static

Definition at line 3917 of file index.cpp.

3918{
3919 QCString projectName = Config_getString(PROJECT_NAME);
3920 QCString title;
3922 {
3923 title = filterTitle(Doxygen::mainPage->title());
3924 }
3925 return !projectName.isEmpty() && mainPageHasTitle() && qstricmp(title,projectName)!=0;
3926}
static std::unique_ptr< PageDef > mainPage
Definition doxygen.h:101
#define Config_getString(name)
Definition config.h:32
int qstricmp(const char *s1, const char *s2)
Definition qcstring.cpp:442
bool mainPageHasTitle()
Definition util.cpp:6801
QCString filterTitle(const QCString &title)
Definition util.cpp:6133

References Config_getString, filterTitle(), QCString::isEmpty(), Doxygen::mainPage, mainPageHasTitle(), and qstricmp().

Referenced by writePages().

◆ MemberIndexMap_add()

void MemberIndexMap_add ( Index::MemberIndexMap & map,
const std::string & letter,
const MemberDef * md )
static

Definition at line 180 of file index.cpp.

181{
182 auto it = map.find(letter);
183 if (it!=map.end())
184 {
185 it->second.push_back(md);
186 }
187 else
188 {
189 map.emplace(letter,std::vector<const MemberDef*>({md}));
190 }
191}

Referenced by Index::incrementDocumentedClassMembers(), Index::incrementDocumentedFileMembers(), Index::incrementDocumentedModuleMembers(), and Index::incrementDocumentedNamespaceMembers().

◆ quickLinkVisible()

bool quickLinkVisible ( LayoutNavEntry::Kind kind)
static

Definition at line 5559 of file index.cpp.

5560{
5561 const auto &index = Index::instance();
5562 bool showNamespaces = Config_getBool(SHOW_NAMESPACES);
5563 bool showFiles = Config_getBool(SHOW_FILES);
5564 bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
5565 switch (kind)
5566 {
5567 case LayoutNavEntry::MainPage: return TRUE;
5568 case LayoutNavEntry::User: return TRUE;
5569 case LayoutNavEntry::UserGroup: return TRUE;
5570 case LayoutNavEntry::Pages: return index.numIndexedPages()>0;
5571 case LayoutNavEntry::Topics: return index.numDocumentedGroups()>0;
5572 case LayoutNavEntry::Modules: return index.numDocumentedModules()>0;
5573 case LayoutNavEntry::ModuleList: return index.numDocumentedModules()>0;
5574 case LayoutNavEntry::ModuleMembers: return index.numDocumentedModuleMembers(ModuleMemberHighlight::All)>0;
5575 case LayoutNavEntry::Namespaces: return index.numDocumentedNamespaces()>0 && showNamespaces;
5576 case LayoutNavEntry::NamespaceList: return index.numDocumentedNamespaces()>0 && showNamespaces;
5577 case LayoutNavEntry::NamespaceMembers: return index.numDocumentedNamespaceMembers(NamespaceMemberHighlight::All)>0;
5578 case LayoutNavEntry::Concepts: return index.numDocumentedConcepts()>0;
5579 case LayoutNavEntry::Classes: return index.numAnnotatedClasses()>0;
5580 case LayoutNavEntry::ClassList: return index.numAnnotatedClasses()>0;
5581 case LayoutNavEntry::ClassIndex: return index.numAnnotatedClasses()>0;
5582 case LayoutNavEntry::ClassHierarchy: return index.numHierarchyClasses()>0;
5583 case LayoutNavEntry::ClassMembers: return index.numDocumentedClassMembers(ClassMemberHighlight::All)>0 && !sliceOpt;
5584 case LayoutNavEntry::Interfaces: return index.numAnnotatedInterfaces()>0;
5585 case LayoutNavEntry::InterfaceList: return index.numAnnotatedInterfaces()>0;
5586 case LayoutNavEntry::InterfaceIndex: return index.numAnnotatedInterfaces()>0;
5587 case LayoutNavEntry::InterfaceHierarchy: return index.numHierarchyInterfaces()>0;
5588 case LayoutNavEntry::Structs: return index.numAnnotatedStructs()>0;
5589 case LayoutNavEntry::StructList: return index.numAnnotatedStructs()>0;
5590 case LayoutNavEntry::StructIndex: return index.numAnnotatedStructs()>0;
5591 case LayoutNavEntry::Exceptions: return index.numAnnotatedExceptions()>0;
5592 case LayoutNavEntry::ExceptionList: return index.numAnnotatedExceptions()>0;
5593 case LayoutNavEntry::ExceptionIndex: return index.numAnnotatedExceptions()>0;
5594 case LayoutNavEntry::ExceptionHierarchy: return index.numHierarchyExceptions()>0;
5595 case LayoutNavEntry::Files: return index.numDocumentedFiles()>0 && showFiles;
5596 case LayoutNavEntry::FileList: return index.numDocumentedFiles()>0 && showFiles;
5597 case LayoutNavEntry::FileGlobals: return index.numDocumentedFileMembers(FileMemberHighlight::All)>0;
5598 case LayoutNavEntry::Examples: return !Doxygen::exampleLinkedMap->empty();
5599 case LayoutNavEntry::None: // should never happen, means not properly initialized
5600 assert(kind != LayoutNavEntry::None);
5601 return FALSE;
5602 }
5603 return FALSE;
5604}
static PageLinkedMap * exampleLinkedMap
Definition doxygen.h:99
static Index & instance()
Definition index.cpp:106

References ClassMemberHighlight::All, FileMemberHighlight::All, ModuleMemberHighlight::All, NamespaceMemberHighlight::All, Config_getBool, Doxygen::exampleLinkedMap, FALSE, Index::instance(), and TRUE.

◆ renderMemberIndicesAsJs()

template<class T>
void renderMemberIndicesAsJs ( std::ostream & t,
std::function< std::size_t(std::size_t)> numDocumented,
std::function< Index::MemberIndexMap(std::size_t)> getMemberList,
const T *(* getInfo )(size_t hl),
std::size_t total )

Definition at line 5607 of file index.cpp.

5612{
5613 // index items per category member lists
5614 bool firstMember=TRUE;
5615 for (std::size_t i=0;i<total;i++)
5616 {
5617 if (numDocumented(i)>0)
5618 {
5619 t << ",";
5620 if (firstMember)
5621 {
5622 t << "children:[";
5623 firstMember=FALSE;
5624 }
5625 t << "\n{text:\"" << convertToJSString(getInfo(i)->title) << "\",url:\""
5626 << convertToJSString(getInfo(i)->fname+Doxygen::htmlFileExtension) << "\"";
5627
5628 // Check if we have many members, then add sub entries per letter...
5629 // quick alphabetical index
5630 bool quickIndex = numDocumented(i)>maxItemsBeforeQuickIndex;
5631 if (quickIndex)
5632 {
5633 bool multiPageIndex=FALSE;
5634 if (numDocumented(i)>MAX_ITEMS_BEFORE_MULTIPAGE_INDEX)
5635 {
5636 multiPageIndex=TRUE;
5637 }
5638 t << ",children:[\n";
5639 bool firstLetter=TRUE;
5640 for (const auto &[letter,list] : getMemberList(i))
5641 {
5642 if (!firstLetter) t << ",\n";
5643 QCString ci(letter);
5644 QCString is(letterToLabel(ci));
5645 QCString anchor;
5647 QCString fullName = getInfo(i)->fname;
5648 if (!multiPageIndex || firstLetter)
5649 anchor=fullName+extension+"#index_";
5650 else // other pages of multi page index
5651 anchor=fullName+"_"+is+extension+"#index_";
5652 t << "{text:\"" << convertToJSString(ci) << "\",url:\""
5653 << convertToJSString(anchor+convertToId(is)) << "\"}";
5654 firstLetter=FALSE;
5655 }
5656 t << "]";
5657 }
5658 t << "}";
5659 }
5660 }
5661 if (!firstMember)
5662 {
5663 t << "]";
5664 }
5665}
static QCString htmlFileExtension
Definition doxygen.h:122
#define MAX_ITEMS_BEFORE_MULTIPAGE_INDEX
Definition index.cpp:55
const int maxItemsBeforeQuickIndex
Definition index.cpp:341
static QCString letterToLabel(const QCString &startLetter)
Definition index.cpp:2231
QCString convertToJSString(const QCString &s, bool keepEntities, bool singleQuotes)
Definition util.cpp:4539
QCString convertToId(const QCString &s)
Definition util.cpp:4388

References convertToId(), convertToJSString(), FALSE, Doxygen::htmlFileExtension, letterToLabel(), MAX_ITEMS_BEFORE_MULTIPAGE_INDEX, maxItemsBeforeQuickIndex, and TRUE.

Referenced by renderQuickLinksAsJs().

◆ renderQuickLinksAsJs()

bool renderQuickLinksAsJs ( std::ostream & t,
LayoutNavEntry * root,
bool first )
static

Definition at line 5667 of file index.cpp.

5668{
5669 int count=0;
5670 for (const auto &entry : root->children())
5671 {
5672 if (entry->visible() && quickLinkVisible(entry->kind())) count++;
5673 }
5674 if (count>0) // at least one item is visible
5675 {
5676 bool firstChild = TRUE;
5677 if (!first) t << ",";
5678 t << "children:[\n";
5679 for (const auto &entry : root->children())
5680 {
5681 if (entry->visible() && quickLinkVisible(entry->kind()))
5682 {
5683 if (!firstChild) t << ",\n";
5684 firstChild=FALSE;
5685 QCString url = entry->url();
5686 if (isURL(url)) url = "^" + url;
5687 t << "{text:\"" << convertToJSString(entry->title()) << "\",url:\""
5688 << convertToJSString(url) << "\"";
5689 bool hasChildren=FALSE;
5690 if (entry->kind()==LayoutNavEntry::ModuleMembers)
5691 {
5692 auto numDoc = [](std::size_t i) {
5694 };
5695 auto memList = [](std::size_t i) {
5697 };
5698 renderMemberIndicesAsJs(t,numDoc,memList,getMmhlInfo,static_cast<std::size_t>(ModuleMemberHighlight::Total));
5699 }
5700 if (entry->kind()==LayoutNavEntry::NamespaceMembers)
5701 {
5702 auto numDoc = [](std::size_t i) {
5704 };
5705 auto memList = [](std::size_t i) {
5707 };
5708 renderMemberIndicesAsJs(t,numDoc,memList,getNmhlInfo,static_cast<std::size_t>(NamespaceMemberHighlight::Total));
5709 }
5710 else if (entry->kind()==LayoutNavEntry::ClassMembers)
5711 {
5712 auto numDoc = [](std::size_t i) {
5714 };
5715 auto memList = [](std::size_t i) {
5717 };
5718 renderMemberIndicesAsJs(t,numDoc,memList,getCmhlInfo,static_cast<std::size_t>(ClassMemberHighlight::Total));
5719 }
5720 else if (entry->kind()==LayoutNavEntry::FileGlobals)
5721 {
5722 auto numDoc = [](std::size_t i) {
5724 };
5725 auto memList = [](std::size_t i) {
5727 };
5728 renderMemberIndicesAsJs(t,numDoc,memList,getFmhlInfo,static_cast<std::size_t>(FileMemberHighlight::Total));
5729 }
5730 else // recursive into child list
5731 {
5732 hasChildren = renderQuickLinksAsJs(t,entry.get(),FALSE);
5733 }
5734 if (hasChildren) t << "]";
5735 t << "}";
5736 }
5737 }
5738 }
5739 return count>0;
5740}
MemberIndexMap isClassIndexLetterUsed(ClassMemberHighlight::Enum e) const
Definition index.cpp:136
int numDocumentedClassMembers(ClassMemberHighlight::Enum e) const
Definition index.cpp:131
int numDocumentedModuleMembers(ModuleMemberHighlight::Enum e) const
Definition index.cpp:134
int numDocumentedNamespaceMembers(NamespaceMemberHighlight::Enum e) const
Definition index.cpp:133
int numDocumentedFileMembers(FileMemberHighlight::Enum e) const
Definition index.cpp:132
MemberIndexMap isFileIndexLetterUsed(FileMemberHighlight::Enum e) const
Definition index.cpp:141
MemberIndexMap isModuleIndexLetterUsed(ModuleMemberHighlight::Enum e) const
Definition index.cpp:151
MemberIndexMap isNamespaceIndexLetterUsed(NamespaceMemberHighlight::Enum e) const
Definition index.cpp:146
static bool quickLinkVisible(LayoutNavEntry::Kind kind)
Definition htmlgen.cpp:2743
static bool renderQuickLinksAsJs(std::ostream &t, LayoutNavEntry *root, bool first)
Definition index.cpp:5667
void renderMemberIndicesAsJs(std::ostream &t, std::function< std::size_t(std::size_t)> numDocumented, std::function< Index::MemberIndexMap(std::size_t)> getMemberList, const T *(*getInfo)(size_t hl), std::size_t total)
Definition index.cpp:5607
static const FmhlInfo * getFmhlInfo(size_t hl)
Definition index.cpp:3298
static const MmhlInfo * getMmhlInfo(size_t hl)
Definition index.cpp:3665
static const NmhlInfo * getNmhlInfo(size_t hl)
Definition index.cpp:3480
static const CmhlInfo * getCmhlInfo(size_t hl)
Definition index.cpp:3110
const LayoutNavEntryList & children() const
Definition layout.h:219
bool isURL(const QCString &url)
Checks whether the given url starts with a supported protocol.
Definition util.cpp:6432

References LayoutNavEntry::children(), convertToJSString(), FALSE, getCmhlInfo(), getFmhlInfo(), getMmhlInfo(), getNmhlInfo(), Index::instance(), Index::isClassIndexLetterUsed(), Index::isFileIndexLetterUsed(), Index::isModuleIndexLetterUsed(), Index::isNamespaceIndexLetterUsed(), isURL(), Index::numDocumentedClassMembers(), Index::numDocumentedFileMembers(), Index::numDocumentedModuleMembers(), Index::numDocumentedNamespaceMembers(), quickLinkVisible(), renderMemberIndicesAsJs(), renderQuickLinksAsJs(), ClassMemberHighlight::Total, FileMemberHighlight::Total, ModuleMemberHighlight::Total, NamespaceMemberHighlight::Total, and TRUE.

Referenced by renderQuickLinksAsJs(), and writeMenuData().

◆ startFile()

void startFile ( OutputList & ol,
const QCString & name,
const QCString & manName,
const QCString & title,
HighlightedItem hli,
bool additionalIndices,
const QCString & altSidebarName,
int hierarchyLevel,
const QCString & allMembersFile )

Definition at line 401 of file index.cpp.

404{
405 bool disableIndex = Config_getBool(DISABLE_INDEX);
406 bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
407 bool fullSidebar = Config_getBool(FULL_SIDEBAR);
408 bool quickLinksAfterSplitbar = !disableIndex && generateTreeView && fullSidebar;
409 ol.startFile(name,manName,title,hierarchyLevel);
411 if (!disableIndex && !quickLinksAfterSplitbar)
412 {
413 ol.writeQuickLinks(hli,name);
414 }
415 if (!additionalIndices)
416 {
417 ol.endQuickIndices();
418 }
419 ol.writeSplitBar(!altSidebarName.isEmpty() ? altSidebarName : name, allMembersFile);
420 if (quickLinksAfterSplitbar)
421 {
422 ol.writeQuickLinks(hli,name);
423 }
424 ol.writeSearchInfo();
425}
void writeSearchInfo()
Definition outputlist.h:399
void startFile(const QCString &name, const QCString &manName, const QCString &title, int hierarchyLevel=0)
void startQuickIndices()
Definition outputlist.h:604
void endQuickIndices()
Definition outputlist.h:606
void writeSplitBar(const QCString &name, const QCString &allMembersFile)
Definition outputlist.h:608
void writeQuickLinks(HighlightedItem hli, const QCString &file, bool extraTabs=false)
Definition outputlist.h:614

References Config_getBool, OutputList::endQuickIndices(), QCString::isEmpty(), OutputList::startFile(), OutputList::startQuickIndices(), OutputList::writeQuickLinks(), OutputList::writeSearchInfo(), and OutputList::writeSplitBar().

Referenced by generateExampleDocs(), writeAlphabeticalExceptionIndex(), writeAlphabeticalIndex(), writeAlphabeticalInterfaceIndex(), writeAlphabeticalStructIndex(), writeAnnotatedIndexGeneric(), writeConceptIndex(), writeDirIndex(), ClassDefImpl::writeDocumentation(), ConceptDefImpl::writeDocumentation(), DirDefImpl::writeDocumentation(), DirRelation::writeDocumentation(), FileDefImpl::writeDocumentation(), GroupDefImpl::writeDocumentation(), ModuleDefImpl::writeDocumentation(), NamespaceDefImpl::writeDocumentation(), PageDefImpl::writeDocumentation(), MemberList::writeDocumentationPage(), writeExampleIndex(), writeFileIndex(), writeGraphicalClassHierarchy(), writeGraphicalExceptionHierarchy(), writeGraphicalInterfaceHierarchy(), writeGraphInfo(), writeHierarchicalExceptionIndex(), writeHierarchicalIndex(), writeHierarchicalInterfaceIndex(), ClassDefImpl::writeMemberList(), writeModuleIndex(), writeNamespaceIndex(), writePageIndex(), FileDefImpl::writeSourceHeader(), writeTopicIndex(), and writeUserGroupStubPage().

◆ startIndexHierarchy()

◆ startQuickIndexItem()

void startQuickIndexItem ( OutputList & ol,
const QCString & l,
bool hl,
bool ,
bool & first )
static

Definition at line 364 of file index.cpp.

366{
367 first=FALSE;
368 ol.writeString(" <li");
369 if (hl) ol.writeString(" class=\"current\"");
370 ol.writeString("><a ");
371 ol.writeString("href=\"");
372 ol.writeString(l);
373 ol.writeString("\">");
374 ol.writeString("<span>");
375}

References FALSE, and OutputList::writeString().

Referenced by writeClassMemberIndexFiltered(), writeFileMemberIndexFiltered(), writeModuleMemberIndexFiltered(), writeNamespaceMemberIndexFiltered(), and writeQuickMemberIndex().

◆ startQuickIndexList()

void startQuickIndexList ( OutputList & ol,
bool letterTabs = FALSE )
static

Definition at line 345 of file index.cpp.

346{
347 if (letterTabs)
348 {
349 ol.writeString(" <div id=\"navrow4\" class=\"tabs3\">\n");
350 }
351 else
352 {
353 ol.writeString(" <div id=\"navrow3\" class=\"tabs2\">\n");
354 }
355 ol.writeString(" <ul class=\"tablist\">\n");
356}

References FALSE, and OutputList::writeString().

Referenced by writeClassMemberIndexFiltered(), writeFileMemberIndexFiltered(), writeModuleMemberIndexFiltered(), writeNamespaceMemberIndexFiltered(), and writeQuickMemberIndex().

◆ startTitle()

void startTitle ( OutputList & ol,
const QCString & fileName,
const DefinitionMutable * def )

Definition at line 384 of file index.cpp.

385{
386 bool generateOutlinePanel = Config_getBool(GENERATE_TREEVIEW) && Config_getBool(PAGE_OUTLINE_PANEL);
388 if (!generateOutlinePanel && def) def->writeSummaryLinks(ol);
389 ol.startTitleHead(fileName);
392}
virtual void writeSummaryLinks(OutputList &) const =0
void startTitleHead(const QCString &fileName)
Definition outputlist.h:405
void startHeaderSection()
Definition outputlist.h:467

References Config_getBool, OutputList::disable(), Man, OutputList::pushGeneratorState(), OutputList::startHeaderSection(), OutputList::startTitleHead(), and DefinitionMutable::writeSummaryLinks().

Referenced by generateExampleDocs(), writeAlphabeticalExceptionIndex(), writeAlphabeticalIndex(), writeAlphabeticalInterfaceIndex(), writeAlphabeticalStructIndex(), writeAnnotatedIndexGeneric(), writeConceptIndex(), writeDirIndex(), ClassDefImpl::writeDocumentation(), ConceptDefImpl::writeDocumentation(), DirDefImpl::writeDocumentation(), FileDefImpl::writeDocumentation(), NamespaceDefImpl::writeDocumentation(), writeExampleIndex(), writeFileIndex(), writeGraphicalClassHierarchy(), writeGraphicalExceptionHierarchy(), writeGraphicalInterfaceHierarchy(), writeGraphInfo(), writeHierarchicalExceptionIndex(), writeHierarchicalIndex(), writeHierarchicalInterfaceIndex(), ClassDefImpl::writeMemberList(), writeModuleIndex(), writeNamespaceIndex(), writePageIndex(), FileDefImpl::writeSourceHeader(), writeTopicIndex(), and writeUserGroupStubPage().

◆ writeAlphabeticalClassList()

void writeAlphabeticalClassList ( OutputList & ol,
ClassDef::CompoundType ct,
int  )
static

Definition at line 2280 of file index.cpp.

2281{
2282 bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
2283
2284 // What starting letters are used
2285 UsedIndexLetters indexLettersUsed;
2286
2287 // first count the number of headers
2288 for (const auto &cd : *Doxygen::classLinkedMap)
2289 {
2290 if (sliceOpt && cd->compoundType() != ct)
2291 continue;
2292 if (cd->isLinkableInProject() && !cd->isImplicitTemplateInstance())
2293 {
2294 if (cd->getLanguage()==SrcLangExt::VHDL && !(VhdlDocGen::convert(cd->protection())==VhdlDocGen::ENTITYCLASS ))// no architecture
2295 continue;
2296
2297 // get the first UTF8 character (after the part that should be ignored)
2298 int index = getPrefixIndex(cd->className());
2299 std::string letter = getUTF8CharAt(cd->className().str(),index);
2300 if (!letter.empty())
2301 {
2302 indexLettersUsed.insert(convertUTF8ToUpper(letter));
2303 }
2304 }
2305 }
2306
2307 // write quick link index (row of letters)
2308 QCString alphaLinks = "<div class=\"qindex\">";
2309 bool first=true;
2310 for (const auto &letter : indexLettersUsed)
2311 {
2312 if (!first) alphaLinks += "&#160;|&#160;";
2313 first=false;
2314 QCString li = letterToLabel(letter.c_str());
2315 alphaLinks += "<a class=\"qindex\" href=\"#letter_" +
2316 li + "\">" +
2317 QCString(letter) + "</a>";
2318 }
2319 alphaLinks += "</div>\n";
2320 ol.writeString(alphaLinks);
2321
2322 std::map<std::string, std::vector<const ClassDef*> > classesByLetter;
2323
2324 // fill the columns with the class list (row elements in each column,
2325 // expect for the columns with number >= itemsInLastRow, which get one
2326 // item less.
2327 for (const auto &cd : *Doxygen::classLinkedMap)
2328 {
2329 if (sliceOpt && cd->compoundType() != ct)
2330 continue;
2331 if (cd->getLanguage()==SrcLangExt::VHDL && !(VhdlDocGen::convert(cd->protection())==VhdlDocGen::ENTITYCLASS ))// no architecture
2332 continue;
2333
2334 if (cd->isLinkableInProject() && !cd->isImplicitTemplateInstance())
2335 {
2336 QCString className = cd->className();
2337 int index = getPrefixIndex(className);
2338 std::string letter = getUTF8CharAt(className.str(),index);
2339 if (!letter.empty())
2340 {
2341 letter = convertUTF8ToUpper(letter);
2342 auto it = classesByLetter.find(letter);
2343 if (it!=classesByLetter.end()) // add class to the existing list
2344 {
2345 it->second.push_back(cd.get());
2346 }
2347 else // new entry
2348 {
2349 classesByLetter.emplace(letter, std::vector<const ClassDef*>({ cd.get() }));
2350 }
2351 }
2352 }
2353 }
2354
2355 // sort the class lists per letter while ignoring the prefix
2356 for (auto &[letter,list] : classesByLetter)
2357 {
2358 std::stable_sort(list.begin(), list.end(),
2359 [](const auto &c1,const auto &c2)
2360 {
2361 QCString n1 = c1->className();
2362 QCString n2 = c2->className();
2363 return qstricmp_sort(n1.data()+getPrefixIndex(n1), n2.data()+getPrefixIndex(n2))<0;
2364 });
2365 }
2366
2367 // generate table
2368 if (!classesByLetter.empty())
2369 {
2370 ol.writeString("<div class=\"classindex\">\n");
2371 int counter=0;
2372 for (const auto &cl : classesByLetter)
2373 {
2374 QCString parity = (counter++%2)==0 ? "even" : "odd";
2375 ol.writeString("<dl class=\"classindex " + parity + "\">\n");
2376
2377 // write character heading
2378 ol.writeString("<dt class=\"alphachar\">");
2379 QCString s = letterToLabel(cl.first.c_str());
2380 ol.writeString("<a id=\"letter_");
2381 ol.writeString(s);
2382 ol.writeString("\" name=\"letter_");
2383 ol.writeString(s);
2384 ol.writeString("\">");
2385 ol.writeString(cl.first.c_str());
2386 ol.writeString("</a>");
2387 ol.writeString("</dt>\n");
2388
2389 // write class links
2390 for (const auto &cd : cl.second)
2391 {
2392 ol.writeString("<dd>");
2393 QCString namesp,cname;
2394 extractNamespaceName(cd->name(),cname,namesp);
2395 QCString nsDispName;
2396 SrcLangExt lang = cd->getLanguage();
2398 if (sep!="::")
2399 {
2400 nsDispName=substitute(namesp,"::",sep);
2401 cname=substitute(cname,"::",sep);
2402 }
2403 else
2404 {
2405 nsDispName=namesp;
2406 }
2407
2408 ol.writeObjectLink(cd->getReference(),
2409 cd->getOutputFileBase(),cd->anchor(),cname);
2410 if (!namesp.isEmpty())
2411 {
2412 ol.writeString(" (");
2413 NamespaceDef *nd = getResolvedNamespace(namesp);
2414 if (nd && nd->isLinkable())
2415 {
2417 nd->getOutputFileBase(),QCString(),nsDispName);
2418 }
2419 else
2420 {
2421 ol.docify(nsDispName);
2422 }
2423 ol.writeString(")");
2424 }
2425 ol.writeString("</dd>");
2426 }
2427
2428 ol.writeString("</dl>\n");
2429 }
2430 ol.writeString("</div>\n");
2431 }
2432}
virtual bool isLinkable() const =0
virtual QCString getReference() const =0
virtual QCString getOutputFileBase() const =0
An abstract interface of a namespace symbol.
void writeObjectLink(const QCString &ref, const QCString &file, const QCString &anchor, const QCString &name)
Definition outputlist.h:441
void docify(const QCString &s)
Definition outputlist.h:439
const std::string & str() const
Definition qcstring.h:537
static VhdlClasses convert(Protection prot)
Definition vhdldocgen.h:80
std::set< std::string > UsedIndexLetters
Definition index.cpp:2277
NamespaceDef * getResolvedNamespace(const QCString &name)
QCString substitute(const QCString &s, const QCString &src, const QCString &dst)
substitute all occurrences of src in s by dst
Definition qcstring.cpp:477
SrcLangExt
Definition types.h:207
std::string convertUTF8ToUpper(const std::string &input)
Converts the input string into a upper case version, also taking into account non-ASCII characters th...
Definition utf8.cpp:192
std::string getUTF8CharAt(const std::string &input, size_t pos)
Returns the UTF8 character found at byte position pos in the input string.
Definition utf8.cpp:127
void extractNamespaceName(const QCString &scopeName, QCString &className, QCString &namespaceName, bool allowEmptyClass)
Definition util.cpp:4213
QCString getLanguageSpecificSeparator(SrcLangExt lang, bool classScope)
Returns the scope separator to use given the programming language lang.
Definition util.cpp:6416
int getPrefixIndex(const QCString &name)
Definition util.cpp:3752

References Doxygen::classLinkedMap, Config_getBool, VhdlDocGen::convert(), convertUTF8ToUpper(), OutputList::docify(), VhdlDocGen::ENTITYCLASS, extractNamespaceName(), getLanguageSpecificSeparator(), Definition::getOutputFileBase(), getPrefixIndex(), Definition::getReference(), getResolvedNamespace(), getUTF8CharAt(), QCString::isEmpty(), Definition::isLinkable(), letterToLabel(), QCString::str(), substitute(), OutputList::writeObjectLink(), and OutputList::writeString().

Referenced by writeAlphabeticalExceptionIndex(), writeAlphabeticalIndex(), writeAlphabeticalInterfaceIndex(), and writeAlphabeticalStructIndex().

◆ writeAlphabeticalExceptionIndex()

void writeAlphabeticalExceptionIndex ( OutputList & ol)
static

Definition at line 2523 of file index.cpp.

2524{
2525 if (Index::instance().numAnnotatedExceptions()==0) return;
2526 ol.pushGeneratorState();
2528 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ExceptionIndex);
2529 QCString title = lne ? lne->title() : theTranslator->trExceptionIndex();
2530 bool addToIndex = lne==nullptr || lne->visible();
2531
2532 startFile(ol,"exceptions",QCString(),title,HighlightedItem::Exceptions);
2533
2534 startTitle(ol,QCString());
2535 ol.parseText(title);
2536 endTitle(ol,QCString(),QCString());
2537
2538 if (addToIndex)
2539 {
2540 Doxygen::indexList->addContentsItem(FALSE,title,QCString(),"exceptions",QCString(),FALSE,TRUE);
2541 }
2542
2543 ol.startContents();
2544 writeAlphabeticalClassList(ol, ClassDef::Exception, Index::instance().numAnnotatedExceptions());
2545 endFile(ol); // contains ol.endContents()
2546
2547 ol.popGeneratorState();
2548}
@ Exception
Definition classdef.h:115
LayoutNavEntry * rootNavEntry() const
returns the (invisible) root of the navigation tree.
Definition layout.cpp:1446
void startContents()
Definition outputlist.h:620
void parseText(const QCString &textStr)
void startTitle(OutputList &ol, const QCString &fileName, const DefinitionMutable *def)
Definition index.cpp:384
void endTitle(OutputList &ol, const QCString &fileName, const QCString &name)
Definition index.cpp:394
void startFile(OutputList &ol, const QCString &name, const QCString &manName, const QCString &title, HighlightedItem hli, bool additionalIndices, const QCString &altSidebarName, int hierarchyLevel, const QCString &allMembersFile)
Definition index.cpp:401
static void writeAlphabeticalClassList(OutputList &ol, ClassDef::CompoundType ct, int)
Definition index.cpp:2280
Base class for the layout of a navigation item at the top of the HTML pages.
Definition layout.h:156
QCString title() const
Definition layout.h:216
LayoutNavEntry * find(LayoutNavEntry::Kind k, const QCString &file=QCString()) const
Definition layout.cpp:133
bool visible() const
Definition layout.h:222

References OutputList::disableAllBut(), endFile(), endTitle(), ClassDef::Exception, Exceptions, FALSE, LayoutNavEntry::find(), Html, Doxygen::indexList, Index::instance(), LayoutDocManager::instance(), OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), startFile(), startTitle(), theTranslator, LayoutNavEntry::title(), TRUE, LayoutNavEntry::visible(), and writeAlphabeticalClassList().

Referenced by writeIndexHierarchyEntries().

◆ writeAlphabeticalIndex()

void writeAlphabeticalIndex ( OutputList & ol)
static

Definition at line 2436 of file index.cpp.

2437{
2438 if (Index::instance().numAnnotatedClasses()==0) return;
2439 ol.pushGeneratorState();
2441 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassIndex);
2442 QCString title = lne ? lne->title() : theTranslator->trCompoundIndex();
2443 bool addToIndex = lne==nullptr || lne->visible();
2444
2445 startFile(ol,"classes",QCString(),title,HighlightedItem::Classes);
2446
2447 startTitle(ol,QCString());
2448 ol.parseText(title);
2449 endTitle(ol,QCString(),QCString());
2450
2451 if (addToIndex)
2452 {
2453 Doxygen::indexList->addContentsItem(FALSE,title,QCString(),"classes",QCString(),FALSE,TRUE);
2454 }
2455
2456 ol.startContents();
2457 writeAlphabeticalClassList(ol, ClassDef::Class, Index::instance().numAnnotatedClasses());
2458 endFile(ol); // contains ol.endContents()
2459
2460 ol.popGeneratorState();
2461}

References ClassDef::Class, Classes, OutputList::disableAllBut(), endFile(), endTitle(), FALSE, LayoutNavEntry::find(), Html, Doxygen::indexList, Index::instance(), LayoutDocManager::instance(), OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), startFile(), startTitle(), theTranslator, LayoutNavEntry::title(), TRUE, LayoutNavEntry::visible(), and writeAlphabeticalClassList().

Referenced by writeIndexHierarchyEntries().

◆ writeAlphabeticalInterfaceIndex()

void writeAlphabeticalInterfaceIndex ( OutputList & ol)
static

Definition at line 2465 of file index.cpp.

2466{
2467 if (Index::instance().numAnnotatedInterfaces()==0) return;
2468 ol.pushGeneratorState();
2470 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::InterfaceIndex);
2471 QCString title = lne ? lne->title() : theTranslator->trInterfaceIndex();
2472 bool addToIndex = lne==nullptr || lne->visible();
2473
2474 startFile(ol,"interfaces",QCString(),title,HighlightedItem::Interfaces);
2475
2476 startTitle(ol,QCString());
2477 ol.parseText(title);
2478 endTitle(ol,QCString(),QCString());
2479
2480 if (addToIndex)
2481 {
2482 Doxygen::indexList->addContentsItem(FALSE,title,QCString(),"interfaces",QCString(),FALSE,TRUE);
2483 }
2484
2485 ol.startContents();
2486 writeAlphabeticalClassList(ol, ClassDef::Interface, Index::instance().numAnnotatedInterfaces());
2487 endFile(ol); // contains ol.endContents()
2488
2489 ol.popGeneratorState();
2490}
@ Interface
Definition classdef.h:112

References OutputList::disableAllBut(), endFile(), endTitle(), FALSE, LayoutNavEntry::find(), Html, Doxygen::indexList, Index::instance(), LayoutDocManager::instance(), ClassDef::Interface, Interfaces, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), startFile(), startTitle(), theTranslator, LayoutNavEntry::title(), TRUE, LayoutNavEntry::visible(), and writeAlphabeticalClassList().

Referenced by writeIndexHierarchyEntries().

◆ writeAlphabeticalStructIndex()

void writeAlphabeticalStructIndex ( OutputList & ol)
static

Definition at line 2494 of file index.cpp.

2495{
2496 if (Index::instance().numAnnotatedStructs()==0) return;
2497 ol.pushGeneratorState();
2499 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::StructIndex);
2500 QCString title = lne ? lne->title() : theTranslator->trStructIndex();
2501 bool addToIndex = lne==nullptr || lne->visible();
2502
2503 startFile(ol,"structs",QCString(),title,HighlightedItem::Structs);
2504
2505 startTitle(ol,QCString());
2506 ol.parseText(title);
2507 endTitle(ol,QCString(),QCString());
2508
2509 if (addToIndex)
2510 {
2511 Doxygen::indexList->addContentsItem(FALSE,title,QCString(),"structs",QCString(),FALSE,TRUE);
2512 }
2513
2514 ol.startContents();
2515 writeAlphabeticalClassList(ol, ClassDef::Struct, Index::instance().numAnnotatedStructs());
2516 endFile(ol); // contains ol.endContents()
2517
2518 ol.popGeneratorState();
2519}

References OutputList::disableAllBut(), endFile(), endTitle(), FALSE, LayoutNavEntry::find(), Html, Doxygen::indexList, Index::instance(), LayoutDocManager::instance(), OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), startFile(), startTitle(), ClassDef::Struct, Structs, theTranslator, LayoutNavEntry::title(), TRUE, LayoutNavEntry::visible(), and writeAlphabeticalClassList().

Referenced by writeIndexHierarchyEntries().

◆ writeAnnotatedClassList()

void writeAnnotatedClassList ( OutputList & ol,
ClassDef::CompoundType ct )
static

Definition at line 2153 of file index.cpp.

2154{
2155 //LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassList);
2156 //bool addToIndex = lne==nullptr || lne->visible();
2157 bool first=TRUE;
2158
2159 bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
2160
2161 for (const auto &cd : *Doxygen::classLinkedMap)
2162 {
2163 if (cd->getLanguage()==SrcLangExt::VHDL &&
2164 (VhdlDocGen::convert(cd->protection())==VhdlDocGen::PACKAGECLASS ||
2166 ) // no architecture
2167 {
2168 continue;
2169 }
2170 if (first)
2171 {
2172 ol.startIndexList();
2173 first=FALSE;
2174 }
2175
2176 if (sliceOpt && cd->compoundType() != ct)
2177 {
2178 continue;
2179 }
2180
2181 ol.pushGeneratorState();
2182 if (cd->isEmbeddedInOuterScope())
2183 {
2187 }
2188 if (cd->isLinkableInProject() && !cd->isImplicitTemplateInstance())
2189 {
2190 ol.startIndexKey();
2191 if (cd->getLanguage()==SrcLangExt::VHDL)
2192 {
2194 ol.docify(prot);
2195 ol.writeString(" ");
2196 }
2197 ol.writeObjectLink(QCString(),cd->getOutputFileBase(),cd->anchor(),cd->displayName());
2198 ol.endIndexKey();
2199 bool hasBrief = !cd->briefDescription().isEmpty();
2200 ol.startIndexValue(hasBrief);
2201 if (hasBrief)
2202 {
2203 ol.generateDoc(
2204 cd->briefFile(),cd->briefLine(),
2205 cd.get(),nullptr,
2206 cd->briefDescription(TRUE),
2207 FALSE, // indexWords
2208 FALSE, // isExample
2209 QCString(), // example name
2210 TRUE, // single line
2211 TRUE // link from index
2212 );
2213 }
2214 ol.endIndexValue(cd->getOutputFileBase(),hasBrief);
2215
2216 //if (addToIndex)
2217 //{
2218 // addMembersToIndex(cd,LayoutDocManager::Class,cd->displayName(),cd->anchor());
2219 //}
2220 }
2221 ol.popGeneratorState();
2222 }
2223 if (!first) ol.endIndexList();
2224}
void endIndexValue(const QCString &name, bool b)
Definition outputlist.h:429
void startIndexKey()
Definition outputlist.h:423
void endIndexKey()
Definition outputlist.h:425
void startIndexValue(bool b)
Definition outputlist.h:427
void generateDoc(const QCString &fileName, int startLine, const Definition *ctx, const MemberDef *md, const QCString &docStr, bool indexWords, bool isExample, const QCString &exampleName, bool singleLine, bool linkFromIndex, bool markdownSupport=Config_getBool(MARKDOWN_SUPPORT), bool autolinkSupport=Config_getBool(AUTOLINK_SUPPORT))
static QCString getProtectionName(int prot)

References Doxygen::classLinkedMap, Config_getBool, VhdlDocGen::convert(), OutputList::disable(), Docbook, OutputList::docify(), OutputList::endIndexKey(), OutputList::endIndexList(), OutputList::endIndexValue(), FALSE, OutputList::generateDoc(), VhdlDocGen::getProtectionName(), Latex, VhdlDocGen::PACKAGECLASS, VhdlDocGen::PACKBODYCLASS, OutputList::popGeneratorState(), OutputList::pushGeneratorState(), RTF, OutputList::startIndexKey(), OutputList::startIndexList(), OutputList::startIndexValue(), TRUE, OutputList::writeObjectLink(), and OutputList::writeString().

Referenced by writeAnnotatedIndexGeneric().

◆ writeAnnotatedExceptionIndex()

void writeAnnotatedExceptionIndex ( OutputList & ol)
static

Definition at line 2694 of file index.cpp.

2695{
2696 const auto &index = Index::instance();
2698 AnnotatedIndexContext(index.numAnnotatedExceptions(),index.numAnnotatedExceptionsPrinted(),
2699 LayoutNavEntry::ExceptionList,LayoutNavEntry::Exceptions,
2700 theTranslator->trExceptionList(),theTranslator->trExceptionListDescription(),
2702 "annotatedexceptions",
2704}
static void writeAnnotatedIndexGeneric(OutputList &ol, const AnnotatedIndexContext ctx)
Definition index.cpp:2577
@ AnnotatedExceptions
Definition index.h:76

References AnnotatedExceptions, ClassDef::Exception, Index::instance(), theTranslator, and writeAnnotatedIndexGeneric().

Referenced by writeIndexHierarchyEntries().

◆ writeAnnotatedIndex()

void writeAnnotatedIndex ( OutputList & ol)
static

Definition at line 2652 of file index.cpp.

2653{
2654 const auto &index = Index::instance();
2656 AnnotatedIndexContext(index.numAnnotatedClasses(),index.numAnnotatedClassesPrinted(),
2657 LayoutNavEntry::ClassList,LayoutNavEntry::Classes,
2658 theTranslator->trCompoundList(),theTranslator->trCompoundListDescription(),
2660 "annotated",
2662}
@ AnnotatedClasses
Definition index.h:73

References AnnotatedClasses, ClassDef::Class, Index::instance(), theTranslator, and writeAnnotatedIndexGeneric().

Referenced by writeIndexHierarchyEntries().

◆ writeAnnotatedIndexGeneric()

void writeAnnotatedIndexGeneric ( OutputList & ol,
const AnnotatedIndexContext ctx )
static

Definition at line 2577 of file index.cpp.

2578{
2579 //printf("writeAnnotatedIndex: count=%d printed=%d\n",
2580 // annotatedClasses,annotatedClassesPrinted);
2581 if (ctx.numAnnotated==0) return;
2582
2583 ol.pushGeneratorState();
2585 if (ctx.numPrinted==0)
2586 {
2589 }
2591 if (lne==nullptr) lne = LayoutDocManager::instance().rootNavEntry()->find(ctx.fallbackKind); // fall back
2592 QCString title = lne ? lne->title() : ctx.listDefaultTitleText;
2593 bool addToIndex = lne==nullptr || lne->visible();
2594
2595 startFile(ol,ctx.fileBaseName,QCString(),title,ctx.hiItem);
2596
2597 startTitle(ol,QCString());
2598 ol.parseText(title);
2599 endTitle(ol,QCString(),QCString());
2600
2601 ol.startContents();
2602
2603 ol.startTextBlock();
2604 ol.parseText(lne ? lne->intro() : ctx.listDefaultIntroText);
2605 ol.endTextBlock();
2606
2607 // ---------------
2608 // Linear class index for Latex/RTF
2609 // ---------------
2610 ol.pushGeneratorState();
2612 Doxygen::indexList->disable();
2613
2615
2616 Doxygen::indexList->enable();
2617 ol.popGeneratorState();
2618
2619 // ---------------
2620 // Hierarchical class index for HTML
2621 // ---------------
2622 ol.pushGeneratorState();
2624
2625 {
2626 if (addToIndex)
2627 {
2628 Doxygen::indexList->addContentsItem(TRUE,title,QCString(),ctx.fileBaseName,QCString(),TRUE,TRUE);
2629 Doxygen::indexList->incContentsDepth();
2630 }
2631 FTVHelp ftv(false);
2634 TextStream t;
2635 ftv.generateTreeViewInline(t);
2636 ol.writeString(t.str().c_str());
2637 if (addToIndex)
2638 {
2639 Doxygen::indexList->decContentsDepth();
2640 }
2641 }
2642
2643 ol.popGeneratorState();
2644 // ------
2645
2646 endFile(ol); // contains ol.endContents()
2647 ol.popGeneratorState();
2648}
A class that generates a dynamic tree view side panel.
Definition ftvhelp.h:41
void endTextBlock(bool paraBreak=FALSE)
Definition outputlist.h:674
void startTextBlock(bool dense=FALSE)
Definition outputlist.h:672
Text streaming class that buffers data.
Definition textstream.h:36
std::string str() const
Return the contents of the buffer as a std::string object.
Definition textstream.h:229
static void writeAnnotatedClassList(OutputList &ol, ClassDef::CompoundType ct)
Definition index.cpp:2153
static void writeClassTreeInsideNamespace(const NamespaceLinkedRefMap &nsLinkedMap, FTVHelp *ftv, bool rootOnly, bool addToIndex, ClassDef::CompoundType ct)
Definition index.cpp:2005
static void writeClassTree(const ListType &cl, FTVHelp *ftv, bool addToIndex, bool globalOnly, ClassDef::CompoundType ct)
Definition index.cpp:1726
const LayoutNavEntry::Kind fallbackKind
Definition index.cpp:2569
const ClassDef::CompoundType compoundType
Definition index.cpp:2572
const HighlightedItem hiItem
Definition index.cpp:2574
const QCString fileBaseName
Definition index.cpp:2573
const LayoutNavEntry::Kind listKind
Definition index.cpp:2568
const QCString listDefaultTitleText
Definition index.cpp:2570
const int numAnnotated
Definition index.cpp:2566
const QCString listDefaultIntroText
Definition index.cpp:2571
QCString intro() const
Definition layout.h:217

References Doxygen::classLinkedMap, AnnotatedIndexContext::compoundType, OutputList::disable(), OutputList::disableAllBut(), endFile(), OutputList::endTextBlock(), endTitle(), AnnotatedIndexContext::fallbackKind, AnnotatedIndexContext::fileBaseName, LayoutNavEntry::find(), FTVHelp::generateTreeViewInline(), AnnotatedIndexContext::hiItem, Html, Doxygen::indexList, LayoutDocManager::instance(), LayoutNavEntry::intro(), Latex, AnnotatedIndexContext::listDefaultIntroText, AnnotatedIndexContext::listDefaultTitleText, AnnotatedIndexContext::listKind, Man, Doxygen::namespaceLinkedMap, AnnotatedIndexContext::numAnnotated, AnnotatedIndexContext::numPrinted, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), RTF, OutputList::startContents(), startFile(), OutputList::startTextBlock(), startTitle(), TextStream::str(), LayoutNavEntry::title(), TRUE, LayoutNavEntry::visible(), writeAnnotatedClassList(), writeClassTree(), writeClassTreeInsideNamespace(), and OutputList::writeString().

Referenced by writeAnnotatedExceptionIndex(), writeAnnotatedIndex(), writeAnnotatedInterfaceIndex(), and writeAnnotatedStructIndex().

◆ writeAnnotatedInterfaceIndex()

void writeAnnotatedInterfaceIndex ( OutputList & ol)
static

Definition at line 2666 of file index.cpp.

2667{
2668 const auto &index = Index::instance();
2670 AnnotatedIndexContext(index.numAnnotatedInterfaces(),index.numAnnotatedInterfacesPrinted(),
2671 LayoutNavEntry::InterfaceList,LayoutNavEntry::Interfaces,
2672 theTranslator->trInterfaceList(),theTranslator->trInterfaceListDescription(),
2674 "annotatedinterfaces",
2676}
@ AnnotatedInterfaces
Definition index.h:74

References AnnotatedInterfaces, Index::instance(), ClassDef::Interface, theTranslator, and writeAnnotatedIndexGeneric().

Referenced by writeIndexHierarchyEntries().

◆ writeAnnotatedStructIndex()

void writeAnnotatedStructIndex ( OutputList & ol)
static

Definition at line 2680 of file index.cpp.

2681{
2682 const auto &index = Index::instance();
2684 AnnotatedIndexContext(index.numAnnotatedStructs(),index.numAnnotatedStructsPrinted(),
2685 LayoutNavEntry::StructList,LayoutNavEntry::Structs,
2686 theTranslator->trStructList(),theTranslator->trStructListDescription(),
2688 "annotatedstructs",
2690}
@ AnnotatedStructs
Definition index.h:75

References AnnotatedStructs, Index::instance(), ClassDef::Struct, theTranslator, and writeAnnotatedIndexGeneric().

Referenced by writeIndexHierarchyEntries().

◆ writeClassHierarchy()

void writeClassHierarchy ( OutputList & ol,
FTVHelp * ftv,
bool addToIndex,
ClassDef::CompoundType ct )
static

Definition at line 1063 of file index.cpp.

1064{
1065 ClassDefSet visitedClasses;
1066 if (ftv)
1067 {
1068 ol.pushGeneratorState();
1070 }
1071 bool started=FALSE;
1072 writeClassTreeForList(ol,*Doxygen::classLinkedMap,started,ftv,addToIndex,ct,visitedClasses);
1073 writeClassTreeForList(ol,*Doxygen::hiddenClassLinkedMap,started,ftv,addToIndex,ct,visitedClasses);
1074 if (started)
1075 {
1076 endIndexHierarchy(ol,0);
1077 if (addToIndex)
1078 {
1079 Doxygen::indexList->decContentsDepth();
1080 }
1081 }
1082 if (ftv)
1083 {
1084 ol.popGeneratorState();
1085 }
1086}
std::unordered_set< const ClassDef * > ClassDefSet
Definition classdef.h:95
static void endIndexHierarchy(OutputList &ol, int level)
Definition index.cpp:323
static void writeClassTreeForList(OutputList &ol, const ClassLinkedMap &cl, bool &started, FTVHelp *ftv, bool addToIndex, ClassDef::CompoundType ct, ClassDefSet &visitedClasses)
Definition index.cpp:964

References Doxygen::classLinkedMap, OutputList::disable(), endIndexHierarchy(), FALSE, Doxygen::hiddenClassLinkedMap, Html, Doxygen::indexList, OutputList::popGeneratorState(), OutputList::pushGeneratorState(), and writeClassTreeForList().

Referenced by writeHierarchicalExceptionIndex(), writeHierarchicalIndex(), and writeHierarchicalInterfaceIndex().

◆ writeClassLinkForMember()

void writeClassLinkForMember ( OutputList & ol,
const MemberDef * md,
const QCString & separator,
QCString & prevClassName )
static

Definition at line 2707 of file index.cpp.

2709{
2710 const ClassDef *cd=md->getClassDef();
2711 if ( cd && prevClassName!=cd->displayName())
2712 {
2713 ol.writeString(separator);
2715 cd->displayName());
2716 prevClassName = cd->displayName();
2717 }
2718}
A abstract class representing of a compound symbol.
Definition classdef.h:104
virtual QCString anchor() const =0
virtual QCString displayName(bool includeScope=TRUE) const =0
virtual const ClassDef * getClassDef() const =0

References Definition::anchor(), Definition::displayName(), MemberDef::getClassDef(), Definition::getOutputFileBase(), Definition::getReference(), OutputList::writeObjectLink(), and OutputList::writeString().

Referenced by writeMemberList().

◆ writeClassMemberIndex()

void writeClassMemberIndex ( OutputList & ol)
static

Definition at line 3261 of file index.cpp.

3262{
3263 const auto &index = Index::instance();
3264 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassMembers);
3265 bool addToIndex = lne==nullptr || lne->visible();
3266
3267 if (index.numDocumentedClassMembers(ClassMemberHighlight::All)>0 && addToIndex)
3268 {
3269 Doxygen::indexList->addContentsItem(TRUE,lne ? lne->title() : theTranslator->trCompoundMembers(),QCString(),"functions",QCString());
3270 Doxygen::indexList->incContentsDepth();
3271 }
3281 if (index.numDocumentedClassMembers(ClassMemberHighlight::All)>0 && addToIndex)
3282 {
3283 Doxygen::indexList->decContentsDepth();
3284 }
3285
3286}
static void writeClassMemberIndexFiltered(OutputList &ol, ClassMemberHighlight::Enum hl)
Definition index.cpp:3132

References ClassMemberHighlight::All, ClassMemberHighlight::Enums, ClassMemberHighlight::EnumValues, ClassMemberHighlight::Events, LayoutNavEntry::find(), ClassMemberHighlight::Functions, Doxygen::indexList, Index::instance(), LayoutDocManager::instance(), ClassMemberHighlight::Properties, ClassMemberHighlight::Related, LayoutDocManager::rootNavEntry(), theTranslator, LayoutNavEntry::title(), TRUE, ClassMemberHighlight::Typedefs, ClassMemberHighlight::Variables, LayoutNavEntry::visible(), and writeClassMemberIndexFiltered().

Referenced by writeIndexHierarchyEntries().

◆ writeClassMemberIndexFiltered()

void writeClassMemberIndexFiltered ( OutputList & ol,
ClassMemberHighlight::Enum hl )
static

Definition at line 3132 of file index.cpp.

3133{
3134 const auto &index = Index::instance();
3135 if (index.numDocumentedClassMembers(hl)==0) return;
3136
3137 bool disableIndex = Config_getBool(DISABLE_INDEX);
3138 bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
3139 bool fullSidebar = Config_getBool(FULL_SIDEBAR);
3140 bool dynamicMenus = Config_getBool(HTML_DYNAMIC_MENUS);
3141 bool quickLinksAfterSplitbar = !disableIndex && generateTreeView && fullSidebar;
3142
3143 bool multiPageIndex=FALSE;
3144 if (index.numDocumentedClassMembers(hl)>MAX_ITEMS_BEFORE_MULTIPAGE_INDEX)
3145 {
3146 multiPageIndex=TRUE;
3147 }
3148
3149 ol.pushGeneratorState();
3151
3153 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassMembers);
3154 QCString title = lne ? lne->title() : theTranslator->trCompoundMembers();
3155 if (hl!=ClassMemberHighlight::All) title+=QCString(" - ")+getCmhlInfo(hl)->title;
3156 bool addToIndex = lne==nullptr || lne->visible();
3157
3158 if (addToIndex)
3159 {
3160 Doxygen::indexList->addContentsItem(multiPageIndex,getCmhlInfo(hl)->title,QCString(),
3161 getCmhlInfo(hl)->fname,QCString(),multiPageIndex,TRUE);
3162 if (multiPageIndex) Doxygen::indexList->incContentsDepth();
3163 }
3164
3165 bool first=TRUE;
3166 for (const auto &[letter,list] : index.isClassIndexLetterUsed(hl))
3167 {
3168 QCString fileName = getCmhlInfo(hl)->fname;
3169 if (multiPageIndex)
3170 {
3171 QCString cs(letter);
3172 if (!first)
3173 {
3174 fileName+="_"+letterToLabel(cs);
3175 }
3176 if (addToIndex)
3177 {
3178 Doxygen::indexList->addContentsItem(FALSE,cs,QCString(),fileName,QCString(),FALSE,TRUE);
3179 }
3180 }
3181
3182 bool quickIndex = index.numDocumentedClassMembers(hl)>maxItemsBeforeQuickIndex;
3183
3184 auto writeQuickLinks = [&,cap_letter=letter]()
3185 {
3187 if (!dynamicMenus)
3188 {
3190
3191 // index item for global member list
3194 ol.writeString(fixSpaces(getCmhlInfo(0)->title));
3196
3197 // index items per category member lists
3198 for (int i=1;i<ClassMemberHighlight::Total;i++)
3199 {
3200 if (index.numDocumentedClassMembers(static_cast<ClassMemberHighlight::Enum>(i))>0)
3201 {
3203 ol.writeString(fixSpaces(getCmhlInfo(i)->title));
3204 //printf("multiPageIndex=%d first=%d fileName=%s file=%s title=%s\n",
3205 // multiPageIndex,first,qPrint(fileName),getCmhlInfo(i)->fname,qPrint(getCmhlInfo(i)->title));
3207 }
3208 }
3209
3211
3212 // quick alphabetical index
3213 if (quickIndex)
3214 {
3215 writeQuickMemberIndex(ol,index.isClassIndexLetterUsed(hl),cap_letter,
3216 getCmhlInfo(hl)->fname,multiPageIndex);
3217 }
3218
3219 ol.writeString("</div><!-- main-nav -->\n");
3220 }
3221 };
3222
3223 ol.startFile(fileName+extension,QCString(),title);
3224 ol.startQuickIndices();
3225 if (!disableIndex && !quickLinksAfterSplitbar)
3226 {
3227 writeQuickLinks();
3228 }
3229 ol.endQuickIndices();
3230 ol.writeSplitBar(fileName,QCString());
3231 if (quickLinksAfterSplitbar)
3232 {
3233 writeQuickLinks();
3234 if (!dynamicMenus)
3235 {
3236 ol.writeString("<div id=\"container\">\n");
3237 ol.writeString("<div id=\"doc-content\">\n");
3238 }
3239 }
3240 ol.writeSearchInfo();
3241
3242 ol.startContents();
3243
3244 ol.startTextBlock();
3245 ol.parseText(hl == ClassMemberHighlight::All && lne ? lne->intro() : theTranslator->trCompoundMembersDescriptionTotal(hl));
3246 ol.endTextBlock();
3247
3248 writeMemberList(ol,quickIndex,
3249 multiPageIndex ? letter : std::string(),
3250 index.isClassIndexLetterUsed(hl),
3252 endFile(ol);
3253 first=FALSE;
3254 }
3255
3256 if (multiPageIndex && addToIndex) Doxygen::indexList->decContentsDepth();
3257
3258 ol.popGeneratorState();
3259}
static void endQuickIndexList(OutputList &ol)
Definition index.cpp:358
static void startQuickIndexItem(OutputList &ol, const QCString &l, bool hl, bool, bool &first)
Definition index.cpp:364
static void endQuickIndexItem(OutputList &ol)
Definition index.cpp:377
static void writeQuickMemberIndex(OutputList &ol, const Index::MemberIndexMap &map, const std::string &page, QCString fullName, bool multiPage)
Definition index.cpp:3074
static void writeMemberList(OutputList &ol, bool useSections, const std::string &page, const Index::MemberIndexMap &memberIndexMap, Definition::DefType type)
Definition index.cpp:2761
static void startQuickIndexList(OutputList &ol, bool letterTabs=FALSE)
Definition index.cpp:345
QCString title
Definition index.cpp:3107
const char * fname
Definition index.cpp:3106
QCString fixSpaces(const QCString &s)
Definition util.h:472

References ClassMemberHighlight::All, Config_getBool, OutputList::disableAllBut(), endFile(), endQuickIndexItem(), endQuickIndexList(), OutputList::endQuickIndices(), OutputList::endTextBlock(), FALSE, LayoutNavEntry::find(), fixSpaces(), CmhlInfo::fname, Functions, getCmhlInfo(), Html, Doxygen::htmlFileExtension, Doxygen::indexList, Index::instance(), LayoutDocManager::instance(), LayoutNavEntry::intro(), letterToLabel(), MAX_ITEMS_BEFORE_MULTIPAGE_INDEX, maxItemsBeforeQuickIndex, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), OutputList::startFile(), startQuickIndexItem(), startQuickIndexList(), OutputList::startQuickIndices(), OutputList::startTextBlock(), theTranslator, CmhlInfo::title, LayoutNavEntry::title(), ClassMemberHighlight::Total, TRUE, Definition::TypeClass, LayoutNavEntry::visible(), writeMemberList(), OutputList::writeQuickLinks(), writeQuickMemberIndex(), OutputList::writeSearchInfo(), OutputList::writeSplitBar(), and OutputList::writeString().

Referenced by writeClassMemberIndex().

◆ writeClassTree()

template<class ListType>
void writeClassTree ( const ListType & cl,
FTVHelp * ftv,
bool addToIndex,
bool globalOnly,
ClassDef::CompoundType ct )
static

Definition at line 1726 of file index.cpp.

1727{
1728 bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
1729 for (const auto &cdi : cl)
1730 {
1731 const ClassDef *cd = get_pointer(cdi);
1732 if (cd->getLanguage()==SrcLangExt::VHDL)
1733 {
1736 )// no architecture
1737 {
1738 continue;
1739 }
1740 }
1741
1742 if (sliceOpt && cd->compoundType() != ct)
1743 {
1744 continue;
1745 }
1746
1747 if (!globalOnly ||
1748 cd->getOuterScope()==nullptr ||
1750 )
1751 {
1752 int count=0;
1753 for (const auto &ccd : cd->getClasses())
1754 {
1755 if (ccd->isLinkableInProject() && !ccd->isImplicitTemplateInstance())
1756 {
1757 count++;
1758 }
1759 }
1761 {
1762 if (ftv)
1763 {
1764 ftv->addContentsItem(count>0,cd->displayName(FALSE),cd->getReference(),
1765 cd->getOutputFileBase(),cd->anchor(),FALSE,TRUE,cd);
1766 }
1767 if (addToIndex &&
1768 (cd->getOuterScope()==nullptr ||
1770 )
1771 )
1772 {
1773 addMembersToIndex(cd,LayoutDocManager::Class,
1774 cd->displayName(FALSE),
1775 cd->anchor(),
1776 cd->partOfGroups().empty() && !cd->isSimple());
1777 }
1778 if (count>0)
1779 {
1780 if (ftv) ftv->incContentsDepth();
1781 writeClassTree(cd->getClasses(),ftv,addToIndex,FALSE,ct);
1782 if (ftv) ftv->decContentsDepth();
1783 }
1784 }
1785 }
1786 }
1787}
virtual bool isSimple() const =0
virtual Protection protection() const =0
Return the protection level (Public,Protected,Private) in which this compound was found.
virtual bool isImplicitTemplateInstance() const =0
virtual CompoundType compoundType() const =0
Returns the type of compound this is, i.e.
virtual ClassLinkedRefMap getClasses() const =0
returns the classes nested into this class
virtual SrcLangExt getLanguage() const =0
Returns the programming language this definition was written in.
virtual DefType definitionType() const =0
virtual const GroupList & partOfGroups() const =0
virtual Definition * getOuterScope() const =0
static NamespaceDefMutable * globalScope
Definition doxygen.h:121
void decContentsDepth()
Definition ftvhelp.cpp:154
void incContentsDepth()
Definition ftvhelp.cpp:143
void addContentsItem(bool isDir, const QCString &name, const QCString &ref, const QCString &file, const QCString &anchor, bool separateIndex, bool addToNavIndex, const Definition *def, const QCString &nameAsHtml=QCString())
Definition ftvhelp.cpp:186
bool classVisibleInIndex(const ClassDef *cd)
const ClassDef * get_pointer(const Ptr &p)

References FTVHelp::addContentsItem(), addMembersToIndex(), Definition::anchor(), classVisibleInIndex(), ClassDef::compoundType(), Config_getBool, VhdlDocGen::convert(), FTVHelp::decContentsDepth(), Definition::definitionType(), Definition::displayName(), FALSE, get_pointer(), ClassDef::getClasses(), Definition::getLanguage(), Definition::getOuterScope(), Definition::getOutputFileBase(), Definition::getReference(), Doxygen::globalScope, FTVHelp::incContentsDepth(), ClassDef::isImplicitTemplateInstance(), ClassDef::isSimple(), VhdlDocGen::PACKAGECLASS, VhdlDocGen::PACKBODYCLASS, Definition::partOfGroups(), ClassDef::protection(), TRUE, Definition::TypeClass, and writeClassTree().

Referenced by writeAnnotatedIndexGeneric(), writeClassTree(), writeClassTreeInsideNamespaceElement(), writeModuleTreeNode(), and writeNamespaceTreeElement().

◆ writeClassTreeForList()

void writeClassTreeForList ( OutputList & ol,
const ClassLinkedMap & cl,
bool & started,
FTVHelp * ftv,
bool addToIndex,
ClassDef::CompoundType ct,
ClassDefSet & visitedClasses )
static

Definition at line 964 of file index.cpp.

966{
967 bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
968 for (const auto &cd : cl)
969 {
970 //printf("class %s classHasVisibleRoot=%d isVisibleInHierarchy=%d\n",
971 // qPrint(cd->name()),
972 // classHasVisibleRoot(cd->baseClasses()),
973 // cd->isVisibleInHierarchy()
974 // );
975 bool b = false;
976 if (cd->getLanguage()==SrcLangExt::VHDL)
977 {
978 if (VhdlDocGen::convert(cd->protection())!=VhdlDocGen::ENTITYCLASS)
979 {
980 continue;
981 }
982 b=!classHasVisibleRoot(cd->subClasses());
983 }
984 else if (sliceOpt && cd->compoundType() != ct)
985 {
986 continue;
987 }
988 else
989 {
990 b=!classHasVisibleRoot(cd->baseClasses());
991 }
992
993 if (b) //filter on root classes
994 {
995 if (cd->isVisibleInHierarchy()) // should it be visible
996 {
997 if (!started)
998 {
1000 if (addToIndex)
1001 {
1002 Doxygen::indexList->incContentsDepth();
1003 }
1004 started=TRUE;
1005 }
1006 ol.startIndexListItem();
1007 bool hasChildren = visitedClasses.find(cd.get())==visitedClasses.end() &&
1008 classHasVisibleChildren(cd.get());
1009 //printf("list: Has children %s: %d\n",qPrint(cd->name()),hasChildren);
1010 if (cd->isLinkable())
1011 {
1012 //printf("Writing class %s isLinkable()=%d isLinkableInProject()=%d cd->isImplicitTemplateinstance()=%d\n",
1013 // qPrint(cd->displayName()),cd->isLinkable(),cd->isLinkableInProject(),cd->isImplicitTemplateInstance());
1014 ol.startIndexItem(cd->getReference(),cd->getOutputFileBase());
1015 ol.parseText(cd->displayName());
1016 ol.endIndexItem(cd->getReference(),cd->getOutputFileBase());
1017 if (cd->isReference())
1018 {
1019 ol.startTypewriter();
1020 ol.docify(" [external]");
1021 ol.endTypewriter();
1022 }
1023 if (addToIndex)
1024 {
1025 if (cd->getLanguage()!=SrcLangExt::VHDL) // prevents double insertion in Design Unit List
1026 Doxygen::indexList->addContentsItem(hasChildren,cd->displayName(),cd->getReference(),cd->getOutputFileBase(),cd->anchor(),FALSE,FALSE);
1027 }
1028 if (ftv)
1029 {
1030 ftv->addContentsItem(hasChildren,cd->displayName(),cd->getReference(),cd->getOutputFileBase(),cd->anchor(),FALSE,FALSE,cd.get());
1031 }
1032 }
1033 else
1034 {
1036 ol.parseText(cd->displayName());
1038 if (addToIndex)
1039 {
1040 Doxygen::indexList->addContentsItem(hasChildren,cd->displayName(),QCString(),QCString(),QCString(),FALSE,FALSE);
1041 }
1042 if (ftv)
1043 {
1044 ftv->addContentsItem(hasChildren,cd->displayName(),QCString(),QCString(),QCString(),FALSE,FALSE,cd.get());
1045 }
1046 }
1047 if (cd->getLanguage()==SrcLangExt::VHDL && hasChildren)
1048 {
1049 writeClassTreeToOutput(ol,cd->baseClasses(),1,ftv,addToIndex,visitedClasses);
1050 visitedClasses.insert(cd.get());
1051 }
1052 else if (hasChildren)
1053 {
1054 writeClassTreeToOutput(ol,cd->subClasses(),1,ftv,addToIndex,visitedClasses);
1055 visitedClasses.insert(cd.get());
1056 }
1057 ol.endIndexListItem();
1058 }
1059 }
1060 }
1061}
void startIndexItem(const QCString &ref, const QCString &file)
Definition outputlist.h:435
void endIndexItem(const QCString &ref, const QCString &file)
Definition outputlist.h:437
void startTypewriter()
Definition outputlist.h:451
void endIndexListItem()
Definition outputlist.h:417
void endTypewriter()
Definition outputlist.h:453
void startIndexListItem()
Definition outputlist.h:415
bool classHasVisibleChildren(const ClassDef *cd)
static void writeClassTreeToOutput(OutputList &ol, const BaseClassList &bcl, int level, FTVHelp *ftv, bool addToIndex, ClassDefSet &visitedClasses)
Definition index.cpp:620
static void startIndexHierarchy(OutputList &ol, int level)
Definition index.cpp:307

References FTVHelp::addContentsItem(), classHasVisibleChildren(), classHasVisibleRoot(), Config_getBool, VhdlDocGen::convert(), OutputList::docify(), OutputList::endIndexItem(), OutputList::endIndexListItem(), OutputList::endTypewriter(), VhdlDocGen::ENTITYCLASS, FALSE, Doxygen::indexList, OutputList::parseText(), startIndexHierarchy(), OutputList::startIndexItem(), OutputList::startIndexListItem(), OutputList::startTypewriter(), TRUE, and writeClassTreeToOutput().

Referenced by writeClassHierarchy().

◆ writeClassTreeInsideNamespace() [1/2]

void writeClassTreeInsideNamespace ( const NamespaceLinkedMap & nsLinkedMap,
FTVHelp * ftv,
bool rootOnly,
bool addToIndex,
ClassDef::CompoundType ct )
static

Definition at line 2014 of file index.cpp.

2016{
2017 for (const auto &nd : nsLinkedMap)
2018 {
2019 writeClassTreeInsideNamespaceElement(nd.get(),ftv,rootOnly,addToIndex,ct);
2020 }
2021}
static void writeClassTreeInsideNamespaceElement(const NamespaceDef *nd, FTVHelp *ftv, bool rootOnly, bool addToIndex, ClassDef::CompoundType ct)
Definition index.cpp:1933

References writeClassTreeInsideNamespaceElement().

◆ writeClassTreeInsideNamespace() [2/2]

void writeClassTreeInsideNamespace ( const NamespaceLinkedRefMap & nsLinkedMap,
FTVHelp * ftv,
bool rootOnly,
bool addToIndex,
ClassDef::CompoundType ct )
static

Definition at line 2005 of file index.cpp.

2007{
2008 for (const auto &nd : nsLinkedMap)
2009 {
2010 writeClassTreeInsideNamespaceElement(nd,ftv,rootOnly,addToIndex,ct);
2011 }
2012}

References writeClassTreeInsideNamespaceElement().

Referenced by writeAnnotatedIndexGeneric(), and writeClassTreeInsideNamespaceElement().

◆ writeClassTreeInsideNamespaceElement()

void writeClassTreeInsideNamespaceElement ( const NamespaceDef * nd,
FTVHelp * ftv,
bool rootOnly,
bool addToIndex,
ClassDef::CompoundType ct )
static

Definition at line 1933 of file index.cpp.

1935{
1936 bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
1937 if (!nd->isAnonymous() &&
1938 (!rootOnly || nd->getOuterScope()==Doxygen::globalScope))
1939 {
1940 bool isDir = namespaceHasNestedClass(nd,sliceOpt,ct);
1941 bool isLinkable = nd->isLinkableInProject();
1942
1943 //printf("writeClassTreeInsideNamespaceElement namespace %s isLinkable=%d isDir=%d\n",qPrint(nd->name()),isLinkable,isDir);
1944
1945 QCString ref;
1946 QCString file;
1947 if (isLinkable)
1948 {
1949 ref = nd->getReference();
1950 file = nd->getOutputFileBase();
1951 if (nd->getLanguage()==SrcLangExt::VHDL) // UGLY HACK
1952 {
1953 file=file.replace(0,qstrlen("namespace"),"class");
1954 }
1955 }
1956
1957 if (isDir)
1958 {
1959 ftv->addContentsItem(isDir,nd->localName(),ref,file,QCString(),FALSE,TRUE,nd);
1960
1961 if (addToIndex)
1962 {
1963 // the namespace entry is already shown under the namespace list so don't
1964 // add it to the nav index and don't create a separate index file for it otherwise
1965 // it will overwrite the one written for the namespace list.
1966 Doxygen::indexList->addContentsItem(isDir,nd->localName(),ref,file,QCString(),
1967 false, // separateIndex
1968 false // addToNavIndex
1969 );
1970 }
1971 if (addToIndex)
1972 {
1973 Doxygen::indexList->incContentsDepth();
1974 }
1975
1976 ftv->incContentsDepth();
1977 writeClassTreeInsideNamespace(nd->getNamespaces(),ftv,FALSE,addToIndex,ct);
1978 ClassLinkedRefMap d = nd->getClasses();
1979 if (sliceOpt)
1980 {
1981 if (ct == ClassDef::Interface)
1982 {
1983 d = nd->getInterfaces();
1984 }
1985 else if (ct == ClassDef::Struct)
1986 {
1987 d = nd->getStructs();
1988 }
1989 else if (ct == ClassDef::Exception)
1990 {
1991 d = nd->getExceptions();
1992 }
1993 }
1994 writeClassTree(d,ftv,addToIndex,FALSE,ct);
1995 ftv->decContentsDepth();
1996
1997 if (addToIndex)
1998 {
1999 Doxygen::indexList->decContentsDepth();
2000 }
2001 }
2002 }
2003}
virtual const QCString & localName() const =0
virtual bool isLinkableInProject() const =0
virtual bool isAnonymous() const =0
virtual ClassLinkedRefMap getStructs() const =0
virtual ClassLinkedRefMap getExceptions() const =0
virtual NamespaceLinkedRefMap getNamespaces() const =0
virtual ClassLinkedRefMap getClasses() const =0
virtual ClassLinkedRefMap getInterfaces() const =0
QCString & replace(size_t index, size_t len, const char *s)
Definition qcstring.cpp:212
bool namespaceHasNestedClass(const NamespaceDef *nd, bool filterClasses, ClassDef::CompoundType ct)
uint32_t qstrlen(const char *str)
Returns the length of string str, or 0 if a null pointer is passed.
Definition qcstring.h:58

References FTVHelp::addContentsItem(), Config_getBool, FTVHelp::decContentsDepth(), ClassDef::Exception, FALSE, NamespaceDef::getClasses(), NamespaceDef::getExceptions(), NamespaceDef::getInterfaces(), Definition::getLanguage(), NamespaceDef::getNamespaces(), Definition::getOuterScope(), Definition::getOutputFileBase(), Definition::getReference(), NamespaceDef::getStructs(), Doxygen::globalScope, FTVHelp::incContentsDepth(), Doxygen::indexList, ClassDef::Interface, Definition::isAnonymous(), Definition::isLinkableInProject(), Definition::localName(), namespaceHasNestedClass(), qstrlen(), QCString::replace(), ClassDef::Struct, TRUE, writeClassTree(), and writeClassTreeInsideNamespace().

Referenced by writeClassTreeInsideNamespace(), and writeClassTreeInsideNamespace().

◆ writeClassTreeToOutput()

void writeClassTreeToOutput ( OutputList & ol,
const BaseClassList & bcl,
int level,
FTVHelp * ftv,
bool addToIndex,
ClassDefSet & visitedClasses )
static

Generates HTML Help tree of classes

Definition at line 620 of file index.cpp.

621{
622 if (bcl.empty()) return;
623 bool started=FALSE;
624 for (const auto &bcd : bcl)
625 {
626 ClassDef *cd=bcd.classDef;
627 if (cd->getLanguage()==SrcLangExt::VHDL && VhdlDocGen::convert(cd->protection())!=VhdlDocGen::ENTITYCLASS)
628 {
629 continue;
630 }
631
632 bool b = cd->getLanguage()==SrcLangExt::VHDL ? classHasVisibleRoot(cd->subClasses()) : classHasVisibleRoot(cd->baseClasses());
633
634 if (cd->isVisibleInHierarchy() && b) // classHasVisibleRoot(cd->baseClasses()))
635 {
636 if (!started)
637 {
638 startIndexHierarchy(ol,level);
639 if (addToIndex)
640 {
641 Doxygen::indexList->incContentsDepth();
642 }
643 if (ftv)
644 {
645 ftv->incContentsDepth();
646 }
647 started=TRUE;
648 }
650 //printf("Passed...\n");
651 bool hasChildren = visitedClasses.find(cd)==visitedClasses.end() &&
653 //printf("tree4: Has children %s: %d\n",qPrint(cd->name()),hasChildren);
654 if (cd->isLinkable())
655 {
656 //printf("Writing class %s\n",qPrint(cd->displayName()));
657 ol.startIndexItem(cd->getReference(),cd->getOutputFileBase());
658 ol.parseText(cd->displayName());
659 ol.endIndexItem(cd->getReference(),cd->getOutputFileBase());
660 if (cd->isReference())
661 {
662 ol.startTypewriter();
663 ol.docify(" [external]");
664 ol.endTypewriter();
665 }
666 if (addToIndex)
667 {
668 Doxygen::indexList->addContentsItem(hasChildren,cd->displayName(),cd->getReference(),cd->getOutputFileBase(),cd->anchor());
669 }
670 if (ftv)
671 {
672 if (cd->getLanguage()==SrcLangExt::VHDL)
673 {
674 ftv->addContentsItem(hasChildren,bcd.usedName,cd->getReference(),cd->getOutputFileBase(),cd->anchor(),FALSE,FALSE,cd);
675 }
676 else
677 {
678 ftv->addContentsItem(hasChildren,cd->displayName(),cd->getReference(),cd->getOutputFileBase(),cd->anchor(),FALSE,FALSE,cd);
679 }
680 }
681 }
682 else
683 {
685 ol.parseText(cd->name());
687 if (addToIndex)
688 {
689 Doxygen::indexList->addContentsItem(hasChildren,cd->displayName(),QCString(),QCString(),QCString());
690 }
691 if (ftv)
692 {
693 ftv->addContentsItem(hasChildren,cd->displayName(),QCString(),QCString(),QCString(),FALSE,FALSE,cd);
694 }
695 }
696 if (hasChildren)
697 {
698 //printf("Class %s at %p visited=%d\n",qPrint(cd->name()),cd,cd->visited);
699 visitedClasses.insert(cd);
700 if (cd->getLanguage()==SrcLangExt::VHDL)
701 {
702 writeClassTreeToOutput(ol,cd->baseClasses(),level+1,ftv,addToIndex,visitedClasses);
703 }
704 else
705 {
706 writeClassTreeToOutput(ol,cd->subClasses(),level+1,ftv,addToIndex,visitedClasses);
707 }
708 }
709 ol.endIndexListItem();
710 }
711 }
712 if (started)
713 {
714 endIndexHierarchy(ol,level);
715 if (addToIndex)
716 {
717 Doxygen::indexList->decContentsDepth();
718 }
719 if (ftv)
720 {
721 ftv->decContentsDepth();
722 }
723 }
724}
virtual bool isVisibleInHierarchy() const =0
the class is visible in a class diagram, or class hierarchy
virtual const BaseClassList & baseClasses() const =0
Returns the list of base classes from which this class directly inherits.
virtual const BaseClassList & subClasses() const =0
Returns the list of sub classes that directly derive from this class.
virtual const QCString & name() const =0

References FTVHelp::addContentsItem(), Definition::anchor(), ClassDef::baseClasses(), classHasVisibleChildren(), classHasVisibleRoot(), VhdlDocGen::convert(), FTVHelp::decContentsDepth(), Definition::displayName(), OutputList::docify(), endIndexHierarchy(), OutputList::endIndexItem(), OutputList::endIndexListItem(), OutputList::endTypewriter(), VhdlDocGen::ENTITYCLASS, FALSE, Definition::getLanguage(), Definition::getOutputFileBase(), Definition::getReference(), FTVHelp::incContentsDepth(), Doxygen::indexList, Definition::isLinkable(), Definition::isReference(), ClassDef::isVisibleInHierarchy(), Definition::name(), OutputList::parseText(), ClassDef::protection(), startIndexHierarchy(), OutputList::startIndexItem(), OutputList::startIndexListItem(), OutputList::startTypewriter(), ClassDef::subClasses(), TRUE, and writeClassTreeToOutput().

Referenced by writeClassTreeForList(), and writeClassTreeToOutput().

◆ writeConceptIndex()

void writeConceptIndex ( OutputList & ol)
static

Definition at line 4693 of file index.cpp.

4694{
4695 if (Index::instance().numDocumentedConcepts()==0) return;
4696 ol.pushGeneratorState();
4697 // 1.{
4700 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Concepts);
4701 QCString title = lne ? lne->title() : theTranslator->trConceptList();
4702 bool addToIndex = lne==nullptr || lne->visible();
4703
4704 startFile(ol,"concepts",QCString(),title,HighlightedItem::Concepts);
4705 startTitle(ol,QCString());
4706 ol.parseText(title);
4707 endTitle(ol,QCString(),QCString());
4708 ol.startContents();
4709 ol.startTextBlock();
4710 ol.parseText(lne ? lne->intro() : theTranslator->trConceptListDescription(Config_getBool(EXTRACT_ALL)));
4711 ol.endTextBlock();
4712
4713 // ---------------
4714 // Normal group index for Latex/RTF
4715 // ---------------
4716 // 2.{
4717 ol.pushGeneratorState();
4719
4720 bool first=TRUE;
4721 for (const auto &cd : *Doxygen::conceptLinkedMap)
4722 {
4723 if (cd->isLinkableInProject())
4724 {
4725 if (first)
4726 {
4727 ol.startIndexList();
4728 first=FALSE;
4729 }
4730 //ol.writeStartAnnoItem("namespace",nd->getOutputFileBase(),0,nd->name());
4731 ol.startIndexKey();
4732 ol.writeObjectLink(QCString(),cd->getOutputFileBase(),QCString(),cd->displayName());
4733 ol.endIndexKey();
4734
4735 bool hasBrief = !cd->briefDescription().isEmpty();
4736 ol.startIndexValue(hasBrief);
4737 if (hasBrief)
4738 {
4739 //ol.docify(" (");
4740 ol.generateDoc(
4741 cd->briefFile(),cd->briefLine(),
4742 cd.get(),nullptr,
4743 cd->briefDescription(TRUE),
4744 FALSE, // index words
4745 FALSE, // isExample
4746 QCString(), // example name
4747 TRUE, // single line
4748 TRUE // link from index
4749 );
4750 //ol.docify(")");
4751 }
4752 ol.endIndexValue(cd->getOutputFileBase(),hasBrief);
4753
4754 }
4755 }
4756 if (!first) ol.endIndexList();
4757
4758 ol.popGeneratorState();
4759 // 2.}
4760
4761 // ---------------
4762 // interactive group index for HTML
4763 // ---------------
4764 // 2.{
4765 ol.pushGeneratorState();
4767
4768 {
4769 if (addToIndex)
4770 {
4771 Doxygen::indexList->addContentsItem(TRUE,title,QCString(),"concepts",QCString(),TRUE,TRUE);
4772 Doxygen::indexList->incContentsDepth();
4773 }
4774 FTVHelp ftv(false);
4775 for (const auto &nd : *Doxygen::namespaceLinkedMap)
4776 {
4777 writeConceptTreeInsideNamespaceElement(nd.get(),&ftv,true,addToIndex);
4778 }
4779 writeConceptRootList(&ftv,addToIndex);
4780 TextStream t;
4781 ftv.generateTreeViewInline(t);
4782 ol.writeString(t.str().c_str());
4783 if (addToIndex)
4784 {
4785 Doxygen::indexList->decContentsDepth();
4786 }
4787 }
4788 ol.popGeneratorState();
4789 // 2.}
4790
4791 endFile(ol);
4792 ol.popGeneratorState();
4793 // 1.}
4794}
static void writeConceptRootList(FTVHelp *ftv, bool addToIndex)
Definition index.cpp:4671
static void writeConceptTreeInsideNamespaceElement(const NamespaceDef *nd, FTVHelp *ftv, bool rootOnly, bool addToIndex)
Definition index.cpp:4620

References Doxygen::conceptLinkedMap, Concepts, Config_getBool, OutputList::disable(), OutputList::disableAllBut(), Docbook, endFile(), OutputList::endIndexKey(), OutputList::endIndexList(), OutputList::endIndexValue(), OutputList::endTextBlock(), endTitle(), FALSE, LayoutNavEntry::find(), OutputList::generateDoc(), FTVHelp::generateTreeViewInline(), Html, Doxygen::indexList, Index::instance(), LayoutDocManager::instance(), LayoutNavEntry::intro(), Man, Doxygen::namespaceLinkedMap, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), startFile(), OutputList::startIndexKey(), OutputList::startIndexList(), OutputList::startIndexValue(), OutputList::startTextBlock(), startTitle(), TextStream::str(), theTranslator, LayoutNavEntry::title(), TRUE, LayoutNavEntry::visible(), writeConceptRootList(), writeConceptTreeInsideNamespaceElement(), OutputList::writeObjectLink(), and OutputList::writeString().

Referenced by writeIndexHierarchyEntries().

◆ writeConceptList()

void writeConceptList ( const ConceptLinkedRefMap & concepts,
FTVHelp * ftv,
bool addToIndex )
static

Definition at line 4587 of file index.cpp.

4588{
4589 for (const auto &cd : concepts)
4590 {
4591 if (cd->isLinkableInProject())
4592 {
4593 if (ftv)
4594 {
4595 ftv->addContentsItem(false,cd->displayName(FALSE),cd->getReference(),
4596 cd->getOutputFileBase(),QCString(),false,cd->partOfGroups().empty(),cd);
4597 }
4598 if (addToIndex)
4599 {
4600 Doxygen::indexList->addContentsItem(false,cd->displayName(FALSE),cd->getReference(),
4601 cd->getOutputFileBase(),QCString(),false,cd->partOfGroups().empty());
4602 }
4603 }
4604 }
4605}

References FTVHelp::addContentsItem(), FALSE, and Doxygen::indexList.

Referenced by writeConceptTreeInsideNamespaceElement(), writeModuleTreeNode(), and writeNamespaceTreeElement().

◆ writeConceptRootList()

void writeConceptRootList ( FTVHelp * ftv,
bool addToIndex )
static

Definition at line 4671 of file index.cpp.

4672{
4673 for (const auto &cd : *Doxygen::conceptLinkedMap)
4674 {
4675 if ((cd->getOuterScope()==nullptr ||
4676 cd->getOuterScope()==Doxygen::globalScope) && cd->isLinkableInProject()
4677 )
4678 {
4679 //printf("*** adding %s hasSubPages=%d hasSections=%d\n",qPrint(pageTitle),hasSubPages,hasSections);
4680 ftv->addContentsItem(
4681 false,cd->localName(),cd->getReference(),cd->getOutputFileBase(),
4682 QCString(),false,cd->partOfGroups().empty(),cd.get());
4683 if (addToIndex)
4684 {
4685 Doxygen::indexList->addContentsItem(
4686 false,cd->localName(),cd->getReference(),cd->getOutputFileBase(),
4687 QCString(),false,cd->partOfGroups().empty(),cd.get());
4688 }
4689 }
4690 }
4691}

References FTVHelp::addContentsItem(), Doxygen::conceptLinkedMap, Doxygen::globalScope, and Doxygen::indexList.

Referenced by writeConceptIndex().

◆ writeConceptTreeInsideNamespace()

void writeConceptTreeInsideNamespace ( const NamespaceLinkedRefMap & nsLinkedMap,
FTVHelp * ftv,
bool rootOnly,
bool addToIndex )
static

Definition at line 4610 of file index.cpp.

4612{
4613 for (const auto &nd : nsLinkedMap)
4614 {
4615 writeConceptTreeInsideNamespaceElement(nd,ftv,rootOnly,addToIndex);
4616 }
4617}

References writeConceptTreeInsideNamespaceElement().

Referenced by writeConceptTreeInsideNamespaceElement().

◆ writeConceptTreeInsideNamespaceElement()

void writeConceptTreeInsideNamespaceElement ( const NamespaceDef * nd,
FTVHelp * ftv,
bool rootOnly,
bool addToIndex )
static

Definition at line 4620 of file index.cpp.

4622{
4623 if (!nd->isAnonymous() &&
4624 (!rootOnly || nd->getOuterScope()==Doxygen::globalScope))
4625 {
4626 bool isDir = namespaceHasNestedConcept(nd);
4627 bool isLinkable = nd->isLinkableInProject();
4628
4629 //printf("writeConceptTreeInsideNamespaceElement namespace %s isLinkable=%d isDir=%d\n",qPrint(nd->name()),isLinkable,isDir);
4630
4631 QCString ref;
4632 QCString file;
4633 if (isLinkable)
4634 {
4635 ref = nd->getReference();
4636 file = nd->getOutputFileBase();
4637 }
4638
4639 if (isDir)
4640 {
4641 ftv->addContentsItem(isDir,nd->localName(),ref,file,QCString(),FALSE,TRUE,nd);
4642
4643 if (addToIndex)
4644 {
4645 // the namespace entry is already shown under the namespace list so don't
4646 // add it to the nav index and don't create a separate index file for it otherwise
4647 // it will overwrite the one written for the namespace list.
4648 Doxygen::indexList->addContentsItem(isDir,nd->localName(),ref,file,QCString(),
4649 false, // separateIndex
4650 false // addToNavIndex
4651 );
4652 }
4653 if (addToIndex)
4654 {
4655 Doxygen::indexList->incContentsDepth();
4656 }
4657
4658 ftv->incContentsDepth();
4660 writeConceptList(nd->getConcepts(),ftv,addToIndex);
4661 ftv->decContentsDepth();
4662
4663 if (addToIndex)
4664 {
4665 Doxygen::indexList->decContentsDepth();
4666 }
4667 }
4668 }
4669}
virtual ConceptLinkedRefMap getConcepts() const =0
static void writeConceptTreeInsideNamespace(const NamespaceLinkedRefMap &nsLinkedMap, FTVHelp *ftv, bool rootOnly, bool addToIndex)
Definition index.cpp:4610
static void writeConceptList(const ConceptLinkedRefMap &concepts, FTVHelp *ftv, bool addToIndex)
Definition index.cpp:4587
bool namespaceHasNestedConcept(const NamespaceDef *nd)

References FTVHelp::addContentsItem(), FTVHelp::decContentsDepth(), FALSE, NamespaceDef::getConcepts(), NamespaceDef::getNamespaces(), Definition::getOuterScope(), Definition::getOutputFileBase(), Definition::getReference(), Doxygen::globalScope, FTVHelp::incContentsDepth(), Doxygen::indexList, Definition::isAnonymous(), Definition::isLinkableInProject(), Definition::localName(), namespaceHasNestedConcept(), TRUE, writeConceptList(), and writeConceptTreeInsideNamespace().

Referenced by writeConceptIndex(), and writeConceptTreeInsideNamespace().

◆ writeDirHierarchy()

void writeDirHierarchy ( OutputList & ol,
FTVHelp * ftv,
bool addToIndex )
static

Definition at line 900 of file index.cpp.

901{
902 if (ftv)
903 {
906 }
908 for (const auto &dd : *Doxygen::dirLinkedMap)
909 {
910 if (dd->getOuterScope()==Doxygen::globalScope)
911 {
912 writeDirTreeNode(ol,dd.get(),0,ftv,addToIndex);
913 }
914 }
915 if (ftv)
916 {
917 for (const auto &fn : *Doxygen::inputNameLinkedMap)
918 {
919 for (const auto &fd : *fn)
920 {
921 if (fd->getDirDef()==nullptr) // top level file
922 {
923 bool src = false;
924 bool doc = fileVisibleInIndex(fd.get(),src);
925 QCString reference, outputBase;
926 if (doc)
927 {
928 reference = fd->getReference();
929 outputBase = fd->getOutputFileBase();
930 }
931 if (doc || src)
932 {
933 ftv->addContentsItem(FALSE,fd->displayName(),
934 reference, outputBase, QCString(),
935 FALSE,FALSE,fd.get());
936 }
937 if (addToIndex)
938 {
939 if (doc)
940 {
941 addMembersToIndex(fd.get(),LayoutDocManager::File,fd->displayName(),QCString(),TRUE,FALSE,&fd->getConcepts());
942 }
943 else if (src)
944 {
945 Doxygen::indexList->addContentsItem(
946 FALSE, fd->displayName(), QCString(),
947 fd->getSourceFileBase(), QCString(), FALSE, TRUE, fd.get());
948 }
949 }
950 }
951 }
952 }
953 }
954 endIndexHierarchy(ol,0);
955 if (ftv)
956 {
958 }
959}
static void writeDirTreeNode(OutputList &ol, const DirDef *dd, int level, FTVHelp *ftv, bool addToIndex)
Definition index.cpp:756

References FTVHelp::addContentsItem(), addMembersToIndex(), Doxygen::dirLinkedMap, OutputList::disable(), endIndexHierarchy(), FALSE, fileVisibleInIndex(), Doxygen::globalScope, Html, Doxygen::indexList, Doxygen::inputNameLinkedMap, OutputList::popGeneratorState(), OutputList::pushGeneratorState(), startIndexHierarchy(), TRUE, and writeDirTreeNode().

Referenced by writeFileIndex().

◆ writeDirIndex()

void writeDirIndex ( OutputList & ol)
static

Definition at line 1541 of file index.cpp.

1542{
1543 if (Index::instance().numDocumentedDirs()==0) return;
1544 ol.pushGeneratorState();
1546
1547 QCString title = theTranslator->trDirectories();
1548 startFile(ol,"dirs",QCString(),title,HighlightedItem::Files);
1549 startTitle(ol,title);
1550 ol.parseText(title);
1551 endTitle(ol,QCString(),QCString());
1552
1553 ol.startIndexList();
1554 for (const auto &dir : *Doxygen::dirLinkedMap)
1555 {
1556 if (dir->hasDocumentation())
1557 {
1558 writeDirTreeNode(ol, dir.get(), 1, nullptr, false);
1559 }
1560 }
1561
1562 ol.endIndexList();
1563
1564 endFile(ol);
1565 ol.popGeneratorState();
1566}

References Doxygen::dirLinkedMap, OutputList::disable(), endFile(), OutputList::endIndexList(), endTitle(), Files, Html, Index::instance(), OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), startFile(), OutputList::startIndexList(), startTitle(), theTranslator, and writeDirTreeNode().

Referenced by writeIndexHierarchyEntries().

◆ writeDirTreeNode()

void writeDirTreeNode ( OutputList & ol,
const DirDef * dd,
int level,
FTVHelp * ftv,
bool addToIndex )
static

Definition at line 756 of file index.cpp.

757{
758 if (level>20)
759 {
760 warn(dd->getDefFileName(),dd->getDefLine(),
761 "maximum nesting level exceeded for directory {}: "
762 "check for possible recursive directory relation!",dd->name());
763 return;
764 }
765
766 if (!dirHasVisibleChildren(dd))
767 {
768 return;
769 }
770
771 bool tocExpand = TRUE; //Config_getBool(TOC_EXPAND);
772 bool isDir = !dd->subDirs().empty() || // there are subdirs
773 (tocExpand && // or toc expand and
774 !dd->getFiles().empty() // there are files
775 );
776 //printf("gd='%s': pageDict=%d\n",qPrint(gd->name()),gd->pageDict->count());
777 if (addToIndex)
778 {
779 Doxygen::indexList->addContentsItem(isDir,dd->shortName(),dd->getReference(),dd->getOutputFileBase(),QCString(),TRUE,TRUE);
780 Doxygen::indexList->incContentsDepth();
781 }
782 if (ftv)
783 {
784 ftv->addContentsItem(isDir,dd->shortName(),dd->getReference(),
786 ftv->incContentsDepth();
787 }
788
791 ol.parseText(dd->shortName());
793 if (dd->isReference())
794 {
795 ol.startTypewriter();
796 ol.docify(" [external]");
797 ol.endTypewriter();
798 }
799
800 // write sub directories
801 if (dd->subDirs().size()>0)
802 {
803 startIndexHierarchy(ol,level+1);
804 for(const auto &subdd : dd->subDirs())
805 {
806 writeDirTreeNode(ol,subdd,level+1,ftv,addToIndex);
807 }
808 endIndexHierarchy(ol,level+1);
809 }
810
811 int fileCount=0;
812 if (!dd->getFiles().empty())
813 {
814 for (const auto &fd : dd->getFiles())
815 {
816 //bool allExternals = Config_getBool(ALLEXTERNALS);
817 //if ((allExternals && fd->isLinkable()) || fd->isLinkableInProject())
818 //{
819 // fileCount++;
820 //}
821 bool genSourceFile = false;
822 if (fileVisibleInIndex(fd,genSourceFile))
823 {
824 fileCount++;
825 }
826 else if (genSourceFile)
827 {
828 fileCount++;
829 }
830 }
831 if (fileCount>0)
832 {
833 startIndexHierarchy(ol,level+1);
834 for (const auto &fd : dd->getFiles())
835 {
836 bool src = false;
837 bool doc = fileVisibleInIndex(fd,src);
838 QCString reference;
839 QCString outputBase;
840 if (doc)
841 {
842 reference = fd->getReference();
843 outputBase = fd->getOutputFileBase();
844 }
845 if (doc || src)
846 {
848 ol.startIndexItem(reference,outputBase);
849 ol.parseText(fd->displayName());
850 ol.endIndexItem(reference,outputBase);
851 ol.endIndexListItem();
852 if (ftv && (src || doc))
853 {
855 fd->displayName(),
856 reference,outputBase,
857 QCString(),FALSE,FALSE,fd);
858 }
859 }
860 }
861 endIndexHierarchy(ol,level+1);
862 }
863 }
864
865 if (tocExpand && addToIndex)
866 {
867 // write files of this directory
868 if (fileCount>0)
869 {
870 for (const auto &fd : dd->getFiles())
871 {
872 bool src = false;
873 bool doc = fileVisibleInIndex(fd,src);
874 if (doc)
875 {
876 addMembersToIndex(fd,LayoutDocManager::File,fd->displayName(),QCString(),
877 !fd->isLinkableViaGroup(),FALSE,&fd->getConcepts());
878 }
879 else if (src)
880 {
881 Doxygen::indexList->addContentsItem(
882 FALSE, fd->name(), QCString(),
883 fd->getSourceFileBase(), QCString(), FALSE, TRUE, fd);
884 }
885 }
886 }
887 }
888 ol.endIndexListItem();
889
890 if (addToIndex)
891 {
892 Doxygen::indexList->decContentsDepth();
893 }
894 if (ftv)
895 {
896 ftv->decContentsDepth();
897 }
898}
virtual QCString getDefFileName() const =0
virtual int getDefLine() const =0
virtual bool isReference() const =0
virtual const QCString shortName() const =0
#define warn(file, line, fmt,...)
Definition message.h:97

References FTVHelp::addContentsItem(), addMembersToIndex(), FTVHelp::decContentsDepth(), dirHasVisibleChildren(), OutputList::docify(), endIndexHierarchy(), OutputList::endIndexItem(), OutputList::endIndexListItem(), OutputList::endTypewriter(), FALSE, fileVisibleInIndex(), Definition::getDefFileName(), Definition::getDefLine(), DirDef::getFiles(), Definition::getOutputFileBase(), Definition::getReference(), FTVHelp::incContentsDepth(), Doxygen::indexList, Definition::isReference(), Definition::name(), OutputList::parseText(), DirDef::shortName(), startIndexHierarchy(), OutputList::startIndexItem(), OutputList::startIndexListItem(), OutputList::startTypewriter(), DirDef::subDirs(), TRUE, warn, and writeDirTreeNode().

Referenced by writeDirHierarchy(), writeDirIndex(), and writeDirTreeNode().

◆ writeExampleIndex()

void writeExampleIndex ( OutputList & ol)
static

Definition at line 3834 of file index.cpp.

3835{
3836 if (Doxygen::exampleLinkedMap->empty()) return;
3837 ol.pushGeneratorState();
3840 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Examples);
3841 QCString title = lne ? lne->title() : theTranslator->trExamples();
3842 bool addToIndex = lne==nullptr || lne->visible();
3843
3844 startFile(ol,"examples",QCString(),title,HighlightedItem::Examples);
3845
3846 startTitle(ol,QCString());
3847 ol.parseText(title);
3848 endTitle(ol,QCString(),QCString());
3849
3850 ol.startContents();
3851
3852 if (addToIndex)
3853 {
3854 Doxygen::indexList->addContentsItem(TRUE,title,QCString(),"examples",QCString(),TRUE,TRUE);
3855 Doxygen::indexList->incContentsDepth();
3856 }
3857
3858 ol.startTextBlock();
3859 ol.parseText(lne ? lne->intro() : theTranslator->trExamplesDescription());
3860 ol.endTextBlock();
3861
3862 ol.startItemList();
3863 for (const auto &pd : *Doxygen::exampleLinkedMap)
3864 {
3865 ol.startItemListItem();
3866 QCString n=pd->getOutputFileBase();
3867 if (!pd->title().isEmpty())
3868 {
3869 ol.writeObjectLink(QCString(),n,QCString(),pd->title());
3870 if (addToIndex)
3871 {
3872 Doxygen::indexList->addContentsItem(FALSE,filterTitle(pd->title()),pd->getReference(),n,QCString(),FALSE,TRUE);
3873 }
3874 }
3875 else
3876 {
3877 ol.writeObjectLink(QCString(),n,QCString(),pd->name());
3878 if (addToIndex)
3879 {
3880 Doxygen::indexList->addContentsItem(FALSE,pd->name(),pd->getReference(),n,QCString(),FALSE,TRUE);
3881 }
3882 }
3883 ol.endItemListItem();
3884 //ol.writeString("\n");
3885 }
3886 ol.endItemList();
3887
3888 if (addToIndex)
3889 {
3890 Doxygen::indexList->decContentsDepth();
3891 }
3892 endFile(ol);
3893 ol.popGeneratorState();
3894}
void startItemListItem()
Definition outputlist.h:459
void endItemListItem()
Definition outputlist.h:461

References OutputList::disable(), Docbook, endFile(), OutputList::endItemList(), OutputList::endItemListItem(), OutputList::endTextBlock(), endTitle(), Doxygen::exampleLinkedMap, Examples, FALSE, filterTitle(), LayoutNavEntry::find(), Doxygen::indexList, LayoutDocManager::instance(), LayoutNavEntry::intro(), Man, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), startFile(), OutputList::startItemList(), OutputList::startItemListItem(), OutputList::startTextBlock(), startTitle(), theTranslator, LayoutNavEntry::title(), TRUE, LayoutNavEntry::visible(), and OutputList::writeObjectLink().

Referenced by writeIndexHierarchyEntries().

◆ writeFileIndex()

void writeFileIndex ( OutputList & ol)
static

Definition at line 1570 of file index.cpp.

1571{
1572 if (Index::instance().numDocumentedFiles()==0 || !Config_getBool(SHOW_FILES)) return;
1573
1574 ol.pushGeneratorState();
1577
1578 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::FileList);
1579 if (lne==nullptr) lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Files); // fall back
1580 QCString title = lne ? lne->title() : theTranslator->trFileList();
1581 bool addToIndex = lne==nullptr || lne->visible();
1582
1583 startFile(ol,"files",QCString(),title,HighlightedItem::Files);
1584 startTitle(ol,QCString());
1585 //if (!Config_getString(PROJECT_NAME).isEmpty())
1586 //{
1587 // title.prepend(Config_getString(PROJECT_NAME)+" ");
1588 //}
1589 ol.parseText(title);
1590 endTitle(ol,QCString(),QCString());
1591 ol.startContents();
1592 ol.startTextBlock();
1593
1594 if (addToIndex)
1595 {
1596 Doxygen::indexList->addContentsItem(TRUE,title,QCString(),"files",QCString(),TRUE,TRUE);
1597 Doxygen::indexList->incContentsDepth();
1598 }
1599
1600 ol.parseText(lne ? lne->intro() : theTranslator->trFileListDescription(Config_getBool(EXTRACT_ALL)));
1601 ol.endTextBlock();
1602
1603 // ---------------
1604 // Flat file index
1605 // ---------------
1606
1607 // 1. {
1608 ol.pushGeneratorState();
1610
1611 ol.startIndexList();
1612 if (Config_getBool(FULL_PATH_NAMES))
1613 {
1614 std::unordered_map<std::string,size_t> pathMap;
1615 std::vector<FilesInDir> outputFiles;
1616
1617 // re-sort input files in (dir,file) output order instead of (file,dir) input order
1618 for (const auto &fn : *Doxygen::inputNameLinkedMap)
1619 {
1620 for (const auto &fd : *fn)
1621 {
1622 QCString path=fd->getPath();
1623 if (path.isEmpty()) path="[external]";
1624 auto it = pathMap.find(path.str());
1625 if (it!=pathMap.end()) // existing path -> append
1626 {
1627 outputFiles.at(it->second).files.push_back(fd.get());
1628 }
1629 else // new path -> create path entry + append
1630 {
1631 pathMap.emplace(path.str(),outputFiles.size());
1632 outputFiles.emplace_back(path);
1633 outputFiles.back().files.push_back(fd.get());
1634 }
1635 }
1636 }
1637
1638 // sort the files by path
1639 std::stable_sort(outputFiles.begin(),
1640 outputFiles.end(),
1641 [](const auto &fp1,const auto &fp2) { return qstricmp_sort(fp1.path,fp2.path)<0; });
1642 // sort the files inside the directory by name
1643 for (auto &fp : outputFiles)
1644 {
1645 std::stable_sort(fp.files.begin(), fp.files.end(), compareFileDefs);
1646 }
1647 // write the results
1648 for (const auto &fp : outputFiles)
1649 {
1650 for (const auto &fd : fp.files)
1651 {
1652 writeSingleFileIndex(ol,fd);
1653 }
1654 }
1655 }
1656 else
1657 {
1658 for (const auto &fn : *Doxygen::inputNameLinkedMap)
1659 {
1660 for (const auto &fd : *fn)
1661 {
1662 writeSingleFileIndex(ol,fd.get());
1663 }
1664 }
1665 }
1666 ol.endIndexList();
1667
1668 // 1. }
1669 ol.popGeneratorState();
1670
1671 // ---------------
1672 // Hierarchical file index for HTML
1673 // ---------------
1674 ol.pushGeneratorState();
1676
1677 {
1678 FTVHelp ftv(false);
1679 writeDirHierarchy(ol,&ftv,addToIndex);
1680 TextStream t;
1681 ftv.generateTreeViewInline(t);
1682 ol.writeString(t.str().c_str());
1683 }
1684
1685 ol.popGeneratorState();
1686 // ------
1687
1688 if (addToIndex)
1689 {
1690 Doxygen::indexList->decContentsDepth();
1691 }
1692
1693 endFile(ol);
1694 ol.popGeneratorState();
1695}
int find(char c, int index=0, bool cs=TRUE) const
Definition qcstring.cpp:43
bool compareFileDefs(const FileDef *fd1, const FileDef *fd2)
Definition filedef.cpp:1932
static void writeSingleFileIndex(OutputList &ol, const FileDef *fd)
Definition index.cpp:1463
static void writeDirHierarchy(OutputList &ol, FTVHelp *ftv, bool addToIndex)
Definition index.cpp:900

References compareFileDefs(), Config_getBool, OutputList::disable(), OutputList::disableAllBut(), Docbook, endFile(), OutputList::endIndexList(), OutputList::endTextBlock(), endTitle(), Files, LayoutNavEntry::find(), QCString::find(), FTVHelp::generateTreeViewInline(), Html, Doxygen::indexList, Doxygen::inputNameLinkedMap, Index::instance(), LayoutDocManager::instance(), LayoutNavEntry::intro(), QCString::isEmpty(), Man, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), startFile(), OutputList::startIndexList(), OutputList::startTextBlock(), startTitle(), QCString::str(), TextStream::str(), theTranslator, LayoutNavEntry::title(), TRUE, LayoutNavEntry::visible(), writeDirHierarchy(), writeSingleFileIndex(), and OutputList::writeString().

Referenced by writeIndexHierarchyEntries().

◆ writeFileLinkForMember()

void writeFileLinkForMember ( OutputList & ol,
const MemberDef * md,
const QCString & separator,
QCString & prevFileName )
static

Definition at line 2720 of file index.cpp.

2722{
2723 const FileDef *fd=md->getFileDef();
2724 if (fd && prevFileName!=fd->name())
2725 {
2726 ol.writeString(separator);
2728 fd->name());
2729 prevFileName = fd->name();
2730 }
2731}
A model of a file symbol.
Definition filedef.h:99
virtual const FileDef * getFileDef() const =0

References Definition::anchor(), MemberDef::getFileDef(), Definition::getOutputFileBase(), Definition::getReference(), Definition::name(), OutputList::writeObjectLink(), and OutputList::writeString().

Referenced by writeMemberList().

◆ writeFileMemberIndex()

void writeFileMemberIndex ( OutputList & ol)
static

Definition at line 3445 of file index.cpp.

3446{
3447 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::FileGlobals);
3448 bool addToIndex = lne==nullptr || lne->visible();
3449 if (Index::instance().numDocumentedFileMembers(FileMemberHighlight::All)>0 && addToIndex)
3450 {
3451 Doxygen::indexList->addContentsItem(true,lne ? lne->title() : theTranslator->trFileMembers(),QCString(),"globals",QCString());
3452 Doxygen::indexList->incContentsDepth();
3453 }
3463 if (Index::instance().numDocumentedFileMembers(FileMemberHighlight::All)>0 && addToIndex)
3464 {
3465 Doxygen::indexList->decContentsDepth();
3466 }
3467
3468}
static void writeFileMemberIndexFiltered(OutputList &ol, FileMemberHighlight::Enum hl)
Definition index.cpp:3321

References FileMemberHighlight::All, FileMemberHighlight::Defines, FileMemberHighlight::Dictionaries, FileMemberHighlight::Enums, FileMemberHighlight::EnumValues, LayoutNavEntry::find(), FileMemberHighlight::Functions, Doxygen::indexList, Index::instance(), LayoutDocManager::instance(), LayoutDocManager::rootNavEntry(), FileMemberHighlight::Sequences, theTranslator, LayoutNavEntry::title(), FileMemberHighlight::Typedefs, FileMemberHighlight::Variables, LayoutNavEntry::visible(), and writeFileMemberIndexFiltered().

Referenced by writeIndexHierarchyEntries().

◆ writeFileMemberIndexFiltered()

void writeFileMemberIndexFiltered ( OutputList & ol,
FileMemberHighlight::Enum hl )
static

Definition at line 3321 of file index.cpp.

3322{
3323 const auto &index = Index::instance();
3324 if (index.numDocumentedFileMembers(hl)==0) return;
3325
3326 bool disableIndex = Config_getBool(DISABLE_INDEX);
3327 bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
3328 bool fullSidebar = Config_getBool(FULL_SIDEBAR);
3329 bool dynamicMenus = Config_getBool(HTML_DYNAMIC_MENUS);
3330 bool quickLinksAfterSplitbar = !disableIndex && generateTreeView && fullSidebar;
3331
3332 bool multiPageIndex=FALSE;
3333 if (Index::instance().numDocumentedFileMembers(hl)>MAX_ITEMS_BEFORE_MULTIPAGE_INDEX)
3334 {
3335 multiPageIndex=TRUE;
3336 }
3337
3338 ol.pushGeneratorState();
3340
3342 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::FileGlobals);
3343 QCString title = lne ? lne->title() : theTranslator->trFileMembers();
3344 bool addToIndex = lne==nullptr || lne->visible();
3345
3346 if (addToIndex)
3347 {
3348 Doxygen::indexList->addContentsItem(multiPageIndex,getFmhlInfo(hl)->title,QCString(),
3349 getFmhlInfo(hl)->fname,QCString(),multiPageIndex,TRUE);
3350 if (multiPageIndex) Doxygen::indexList->incContentsDepth();
3351 }
3352
3353 bool first=TRUE;
3354 for (const auto &[letter,list] : index.isFileIndexLetterUsed(hl))
3355 {
3356 QCString fileName = getFmhlInfo(hl)->fname;
3357 if (multiPageIndex)
3358 {
3359 QCString cs(letter);
3360 if (!first)
3361 {
3362 fileName+="_"+letterToLabel(cs);
3363 }
3364 if (addToIndex)
3365 {
3366 Doxygen::indexList->addContentsItem(FALSE,cs,QCString(),fileName,QCString(),FALSE,TRUE);
3367 }
3368 }
3369
3370 bool quickIndex = index.numDocumentedFileMembers(hl)>maxItemsBeforeQuickIndex;
3371
3372 auto writeQuickLinks = [&,cap_letter=letter]()
3373 {
3375 if (!dynamicMenus)
3376 {
3378
3379 // index item for all file member lists
3382 ol.writeString(fixSpaces(getFmhlInfo(0)->title));
3384
3385 // index items for per category member lists
3386 for (int i=1;i<FileMemberHighlight::Total;i++)
3387 {
3388 if (Index::instance().numDocumentedFileMembers(static_cast<FileMemberHighlight::Enum>(i))>0)
3389 {
3391 getFmhlInfo(i)->fname+Doxygen::htmlFileExtension,hl==i,TRUE,first);
3392 ol.writeString(fixSpaces(getFmhlInfo(i)->title));
3394 }
3395 }
3396
3398
3399 if (quickIndex)
3400 {
3401 writeQuickMemberIndex(ol,index.isFileIndexLetterUsed(hl),cap_letter,
3402 getFmhlInfo(hl)->fname,multiPageIndex);
3403 }
3404
3405 ol.writeString("</div><!-- main-nav -->\n");
3406 }
3407 };
3408
3409 ol.startFile(fileName+extension,QCString(),title);
3410 ol.startQuickIndices();
3411 if (!disableIndex && !quickLinksAfterSplitbar)
3412 {
3413 writeQuickLinks();
3414 }
3415 ol.endQuickIndices();
3416 ol.writeSplitBar(fileName,QCString());
3417 if (quickLinksAfterSplitbar)
3418 {
3419 writeQuickLinks();
3420 if (!dynamicMenus)
3421 {
3422 ol.writeString("<div id=\"container\">\n");
3423 ol.writeString("<div id=\"doc-content\">\n");
3424 }
3425 }
3426 ol.writeSearchInfo();
3427
3428 ol.startContents();
3429
3430 ol.startTextBlock();
3431 ol.parseText(hl == FileMemberHighlight::All && lne ? lne->intro() : theTranslator->trFileMembersDescriptionTotal(hl));
3432 ol.endTextBlock();
3433
3434 writeMemberList(ol,quickIndex,
3435 multiPageIndex ? letter : std::string(),
3436 index.isFileIndexLetterUsed(hl),
3438 endFile(ol);
3439 first=FALSE;
3440 }
3441 if (multiPageIndex && addToIndex) Doxygen::indexList->decContentsDepth();
3442 ol.popGeneratorState();
3443}
const char * fname
Definition index.cpp:3294

References FileMemberHighlight::All, Config_getBool, OutputList::disableAllBut(), endFile(), endQuickIndexItem(), endQuickIndexList(), OutputList::endQuickIndices(), OutputList::endTextBlock(), FALSE, LayoutNavEntry::find(), fixSpaces(), FmhlInfo::fname, getFmhlInfo(), Globals, Html, Doxygen::htmlFileExtension, Doxygen::indexList, Index::instance(), LayoutDocManager::instance(), LayoutNavEntry::intro(), letterToLabel(), MAX_ITEMS_BEFORE_MULTIPAGE_INDEX, maxItemsBeforeQuickIndex, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), OutputList::startFile(), startQuickIndexItem(), startQuickIndexList(), OutputList::startQuickIndices(), OutputList::startTextBlock(), theTranslator, LayoutNavEntry::title(), FileMemberHighlight::Total, TRUE, Definition::TypeFile, LayoutNavEntry::visible(), writeMemberList(), OutputList::writeQuickLinks(), writeQuickMemberIndex(), OutputList::writeSearchInfo(), OutputList::writeSplitBar(), and OutputList::writeString().

Referenced by writeFileMemberIndex().

◆ writeGraphicalClassHierarchy()

void writeGraphicalClassHierarchy ( OutputList & ol)
static

Definition at line 1205 of file index.cpp.

1206{
1207 if (Index::instance().numHierarchyClasses()==0) return;
1209 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassHierarchy);
1210 QCString title = lne ? lne->title() : theTranslator->trClassHierarchy();
1211 startFile(ol,"inherits",QCString(),title,HighlightedItem::ClassHierarchy,FALSE,"hierarchy");
1212 startTitle(ol,QCString());
1213 ol.parseText(title);
1214 endTitle(ol,QCString(),QCString());
1215 ol.startContents();
1216 ol.startTextBlock();
1217 ol.startParagraph();
1218 ol.startTextLink("hierarchy",QCString());
1219 ol.parseText(theTranslator->trGotoTextualHierarchy());
1220 ol.endTextLink();
1221 ol.endParagraph();
1222 ol.endTextBlock();
1225 endFile(ol);
1226 ol.enableAll();
1227}
Represents a graphical class hierarchy.
void writeGraphicalHierarchy(DotGfxHierarchyTable &g)
Definition outputlist.h:670
void startParagraph(const QCString &classDef=QCString())
Definition outputlist.h:409
void endParagraph()
Definition outputlist.h:411
void endTextLink()
Definition outputlist.h:446
void enableAll()
void startTextLink(const QCString &file, const QCString &anchor)
Definition outputlist.h:444

References ClassHierarchy, OutputList::disableAllBut(), OutputList::enableAll(), endFile(), OutputList::endParagraph(), OutputList::endTextBlock(), OutputList::endTextLink(), endTitle(), FALSE, LayoutNavEntry::find(), Html, Index::instance(), LayoutDocManager::instance(), OutputList::parseText(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), startFile(), OutputList::startParagraph(), OutputList::startTextBlock(), OutputList::startTextLink(), startTitle(), theTranslator, LayoutNavEntry::title(), and OutputList::writeGraphicalHierarchy().

Referenced by writeIndexHierarchyEntries().

◆ writeGraphicalExceptionHierarchy()

void writeGraphicalExceptionHierarchy ( OutputList & ol)
static

Definition at line 1415 of file index.cpp.

1416{
1417 if (Index::instance().numHierarchyExceptions()==0) return;
1419 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ExceptionHierarchy);
1420 QCString title = lne ? lne->title() : theTranslator->trExceptionHierarchy();
1421 startFile(ol,"exceptioninherits",QCString(),title,HighlightedItem::ExceptionHierarchy,FALSE,"exceptionhierarchy");
1422 startTitle(ol,QCString());
1423 ol.parseText(title);
1424 endTitle(ol,QCString(),QCString());
1425 ol.startContents();
1426 ol.startTextBlock();
1427 ol.startParagraph();
1428 ol.startTextLink("exceptionhierarchy",QCString());
1429 ol.parseText(theTranslator->trGotoTextualHierarchy());
1430 ol.endTextLink();
1431 ol.endParagraph();
1432 ol.endTextBlock();
1435 endFile(ol);
1436 ol.enableAll();
1437}
@ ExceptionHierarchy
Definition index.h:67

References OutputList::disableAllBut(), OutputList::enableAll(), endFile(), OutputList::endParagraph(), OutputList::endTextBlock(), OutputList::endTextLink(), endTitle(), ClassDef::Exception, ExceptionHierarchy, FALSE, LayoutNavEntry::find(), Html, Index::instance(), LayoutDocManager::instance(), OutputList::parseText(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), startFile(), OutputList::startParagraph(), OutputList::startTextBlock(), OutputList::startTextLink(), startTitle(), theTranslator, LayoutNavEntry::title(), and OutputList::writeGraphicalHierarchy().

Referenced by writeIndexHierarchyEntries().

◆ writeGraphicalInterfaceHierarchy()

void writeGraphicalInterfaceHierarchy ( OutputList & ol)
static

Definition at line 1310 of file index.cpp.

1311{
1312 if (Index::instance().numHierarchyInterfaces()==0) return;
1314 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::InterfaceHierarchy);
1315 QCString title = lne ? lne->title() : theTranslator->trInterfaceHierarchy();
1316 startFile(ol,"interfaceinherits",QCString(),title,HighlightedItem::InterfaceHierarchy,FALSE,"interfacehierarchy");
1317 startTitle(ol,QCString());
1318 ol.parseText(title);
1319 endTitle(ol,QCString(),QCString());
1320 ol.startContents();
1321 ol.startTextBlock();
1322 ol.startParagraph();
1323 ol.startTextLink("interfacehierarchy",QCString());
1324 ol.parseText(theTranslator->trGotoTextualHierarchy());
1325 ol.endTextLink();
1326 ol.endParagraph();
1327 ol.endTextBlock();
1330 endFile(ol);
1331 ol.enableAll();
1332}
@ InterfaceHierarchy
Definition index.h:66

References OutputList::disableAllBut(), OutputList::enableAll(), endFile(), OutputList::endParagraph(), OutputList::endTextBlock(), OutputList::endTextLink(), endTitle(), FALSE, LayoutNavEntry::find(), Html, Index::instance(), LayoutDocManager::instance(), ClassDef::Interface, InterfaceHierarchy, OutputList::parseText(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), startFile(), OutputList::startParagraph(), OutputList::startTextBlock(), OutputList::startTextLink(), startTitle(), theTranslator, LayoutNavEntry::title(), and OutputList::writeGraphicalHierarchy().

Referenced by writeIndexHierarchyEntries().

◆ writeGraphInfo()

void writeGraphInfo ( OutputList & ol)

Definition at line 4063 of file index.cpp.

4064{
4065 if (!Config_getBool(HAVE_DOT) || !Config_getBool(GENERATE_HTML)) return;
4066 ol.pushGeneratorState();
4068
4069 DotLegendGraph gd;
4070 gd.writeGraph(Config_getString(HTML_OUTPUT));
4071
4072 bool oldStripCommentsState = Config_getBool(STRIP_CODE_COMMENTS);
4073 bool oldCreateSubdirs = Config_getBool(CREATE_SUBDIRS);
4074 // temporarily disable the stripping of comments for our own code example!
4075 Config_updateBool(STRIP_CODE_COMMENTS,FALSE);
4076 // temporarily disable create subdirs for linking to our example
4077 Config_updateBool(CREATE_SUBDIRS,FALSE);
4078
4079 startFile(ol,"graph_legend",QCString(),theTranslator->trLegendTitle());
4080 startTitle(ol,QCString());
4081 ol.parseText(theTranslator->trLegendTitle());
4082 endTitle(ol,QCString(),QCString());
4083 ol.startContents();
4084 QCString legendDocs = theTranslator->trLegendDocs();
4085 int s = legendDocs.find("<center>");
4086 int e = legendDocs.find("</center>");
4087 QCString imgExt = getDotImageExtension();
4088 if (imgExt=="svg" && s!=-1 && e!=-1)
4089 {
4090 legendDocs = legendDocs.left(s+8) + "[!-- " + "SVG 0 --]" + legendDocs.mid(e);
4091 //printf("legendDocs=%s\n",qPrint(legendDocs));
4092 }
4093
4094 {
4095 auto fd = createFileDef("","graph_legend.dox");
4096 ol.generateDoc("graph_legend",1,fd.get(),nullptr,legendDocs,FALSE,FALSE,
4098 }
4099
4100 // restore config settings
4101 Config_updateBool(STRIP_CODE_COMMENTS,oldStripCommentsState);
4102 Config_updateBool(CREATE_SUBDIRS,oldCreateSubdirs);
4103
4104 endFile(ol);
4105 ol.popGeneratorState();
4106}
Representation of a legend explaining the meaning of boxes, arrows, and colors.
void writeGraph(const QCString &path)
QCString mid(size_t index, size_t len=static_cast< size_t >(-1)) const
Definition qcstring.h:226
QCString left(size_t len) const
Definition qcstring.h:214
#define Config_updateBool(name, value)
Definition config.h:40
std::unique_ptr< FileDef > createFileDef(const QCString &p, const QCString &n, const QCString &ref, const QCString &dn)
Definition filedef.cpp:268
QCString getDotImageExtension()
Definition util.cpp:6806

References Config_getBool, Config_getString, Config_updateBool, createFileDef(), OutputList::disableAllBut(), endFile(), endTitle(), FALSE, QCString::find(), OutputList::generateDoc(), getDotImageExtension(), Html, QCString::left(), QCString::mid(), OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), OutputList::startContents(), startFile(), startTitle(), theTranslator, and DotLegendGraph::writeGraph().

Referenced by generateOutput().

◆ writeGroupHierarchy()

void writeGroupHierarchy ( OutputList & ol,
FTVHelp * ftv,
bool addToIndex )
static

Definition at line 4355 of file index.cpp.

4356{
4357 if (ftv)
4358 {
4359 ol.pushGeneratorState();
4361 }
4362 startIndexHierarchy(ol,0);
4363 for (const auto &gd : *Doxygen::groupLinkedMap)
4364 {
4365 if (gd->isVisibleInHierarchy())
4366 {
4367 writeGroupTreeNode(ol,gd.get(),0,ftv,addToIndex);
4368 }
4369 }
4370 endIndexHierarchy(ol,0);
4371 if (ftv)
4372 {
4373 ol.popGeneratorState();
4374 }
4375}
static void writeGroupTreeNode(OutputList &ol, const GroupDef *gd, int level, FTVHelp *ftv, bool addToIndex)
Definition index.cpp:4114

References OutputList::disable(), endIndexHierarchy(), Doxygen::groupLinkedMap, Html, OutputList::popGeneratorState(), OutputList::pushGeneratorState(), startIndexHierarchy(), and writeGroupTreeNode().

Referenced by writeTopicIndex().

◆ writeGroupTreeNode()

void writeGroupTreeNode ( OutputList & ol,
const GroupDef * gd,
int level,
FTVHelp * ftv,
bool addToIndex )
static

write groups as hierarchical trees

Definition at line 4114 of file index.cpp.

4115{
4116 //bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
4117 //bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
4118 if (level>20)
4119 {
4120 warn(gd->getDefFileName(),gd->getDefLine(),
4121 "maximum nesting level exceeded for group {}: check for possible recursive group relation!",gd->name());
4122 return;
4123 }
4124
4125 /* Some groups should appear twice under different parent-groups.
4126 * That is why we should not check if it was visited
4127 */
4128 if ((!gd->isASubGroup() || level>0) && gd->isVisible() && gd->isVisibleInHierarchy())
4129 {
4130 //printf("gd->name()=%s #members=%d\n",qPrint(gd->name()),gd->countMembers());
4131 // write group info
4132 bool hasSubGroups = !gd->getSubGroups().empty();
4133 bool hasSubPages = !gd->getPages().empty();
4134 size_t numSubItems = 0;
4135 for (const auto &ml : gd->getMemberLists())
4136 {
4137 if (ml->listType().isDocumentation())
4138 {
4139 numSubItems += ml->size();
4140 }
4141 }
4142 numSubItems += gd->getNamespaces().size();
4143 numSubItems += gd->getClasses().size();
4144 numSubItems += gd->getFiles().size();
4145 numSubItems += gd->getConcepts().size();
4146 numSubItems += gd->getDirs().size();
4147 numSubItems += gd->getPages().size();
4148
4149 bool isDir = hasSubGroups || hasSubPages || numSubItems>0;
4150 QCString title = parseCommentAsText(gd,nullptr,gd->groupTitle(),gd->getDefFileName(),gd->getDefLine());
4151 QCString titleAsHtml = parseCommentAsHtml(gd,nullptr,gd->groupTitle(),gd->getDefFileName(),gd->getDefLine());
4152
4153 //printf("gd='%s': pageDict=%d\n",qPrint(gd->name()),gd->pageDict->count());
4154 if (addToIndex)
4155 {
4156 Doxygen::indexList->addContentsItem(isDir,title,
4158 isDir,TRUE,nullptr,titleAsHtml);
4159 Doxygen::indexList->incContentsDepth();
4160 }
4161 if (ftv)
4162 {
4163 ftv->addContentsItem(hasSubGroups,title,
4165 FALSE,FALSE,gd,titleAsHtml);
4166 ftv->incContentsDepth();
4167 }
4168
4169 ol.startIndexListItem();
4171 ol.generateDoc(gd->getDefFileName(),gd->getDefLine(),
4172 gd,nullptr,gd->groupTitle(),false,false,
4173 QCString(),true,false);
4175
4176 if (gd->isReference())
4177 {
4178 ol.startTypewriter();
4179 ol.docify(" [external]");
4180 ol.endTypewriter();
4181 }
4182
4183 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Group))
4184 {
4185 if (lde->kind()==LayoutDocEntry::MemberDef && addToIndex)
4186 {
4187 const LayoutDocEntryMemberDef *lmd = dynamic_cast<const LayoutDocEntryMemberDef*>(lde.get());
4188 if (lmd)
4189 {
4190 MemberList *ml = gd->getMemberList(lmd->type);
4191 if (ml)
4192 {
4193 for (const auto &md : *ml)
4194 {
4195 const MemberVector &enumList = md->enumFieldList();
4196 isDir = !enumList.empty() && md->isEnumerate();
4197 if (md->isVisible() && !md->isAnonymous())
4198 {
4199 Doxygen::indexList->addContentsItem(isDir,
4200 md->qualifiedName(),md->getReference(),
4201 md->getOutputFileBase(),md->anchor(),FALSE,addToIndex);
4202 }
4203 if (isDir)
4204 {
4205 Doxygen::indexList->incContentsDepth();
4206 for (const auto &emd : enumList)
4207 {
4208 if (emd->isVisible())
4209 {
4210 Doxygen::indexList->addContentsItem(FALSE,
4211 emd->qualifiedName(),emd->getReference(),emd->getOutputFileBase(),
4212 emd->anchor(),FALSE,addToIndex);
4213 }
4214 }
4215 Doxygen::indexList->decContentsDepth();
4216 }
4217 }
4218 }
4219 }
4220 }
4221 else if (lde->kind()==LayoutDocEntry::GroupClasses && addToIndex)
4222 {
4223 for (const auto &cd : gd->getClasses())
4224 {
4225 //bool nestedClassInSameGroup =
4226 // cd->getOuterScope() && cd->getOuterScope()->definitionType()==Definition::TypeClass &&
4227 // cd->getOuterScope()->partOfGroups().empty() && cd->getOuterScope()->partOfGroups()->contains(gd);
4228 //printf("===== GroupClasses: %s visible=%d nestedClassInSameGroup=%d\n",qPrint(cd->name()),cd->isVisible(),nestedClassInSameGroup);
4229 if (cd->isVisible() /*&& !nestedClassInSameGroup*/)
4230 {
4232 LayoutDocManager::Class,
4233 cd->displayName(),
4234 cd->anchor(),
4235 addToIndex,
4236 TRUE);
4237 }
4238 }
4239 }
4240 else if (lde->kind()==LayoutDocEntry::GroupNamespaces && addToIndex && Config_getBool(SHOW_NAMESPACES))
4241 {
4242 for (const auto &nd : gd->getNamespaces())
4243 {
4244 if (nd->isVisible())
4245 {
4246 Doxygen::indexList->addContentsItem(FALSE,
4247 nd->displayName(),nd->getReference(),
4248 nd->getOutputFileBase(),QCString(),FALSE,Config_getBool(SHOW_NAMESPACES));
4249 }
4250 }
4251 }
4252 else if (lde->kind()==LayoutDocEntry::GroupConcepts && addToIndex)
4253 {
4254 for (const auto &cd : gd->getConcepts())
4255 {
4256 if (cd->isVisible())
4257 {
4258 Doxygen::indexList->addContentsItem(FALSE,
4259 cd->displayName(),cd->getReference(),
4260 cd->getOutputFileBase(),QCString(),FALSE,addToIndex);
4261 }
4262 }
4263 }
4264 else if (lde->kind()==LayoutDocEntry::GroupFiles && addToIndex)
4265 {
4266 for (const auto &fd : gd->getFiles())
4267 {
4268 if (fd->isVisible())
4269 {
4270 Doxygen::indexList->addContentsItem(FALSE,
4271 fd->displayName(),fd->getReference(),
4272 fd->getOutputFileBase(),QCString(),FALSE,fd->isLinkableViaGroup());
4273 }
4274 }
4275 }
4276 else if (lde->kind()==LayoutDocEntry::GroupDirs && addToIndex)
4277 {
4278 for (const auto &dd : gd->getDirs())
4279 {
4280 if (dd->isVisible())
4281 {
4282 Doxygen::indexList->addContentsItem(FALSE,
4283 dd->shortName(),dd->getReference(),
4284 dd->getOutputFileBase(),QCString(),FALSE,FALSE);
4285 }
4286 }
4287 }
4288 else if (lde->kind()==LayoutDocEntry::GroupPageDocs && addToIndex)
4289 {
4290 for (const auto &pd : gd->getPages())
4291 {
4292 const SectionInfo *si=nullptr;
4293 if (!pd->name().isEmpty()) si=SectionManager::instance().find(pd->name());
4294 hasSubPages = pd->hasSubPages();
4295 bool hasSections = pd->hasSections();
4296 QCString pageTitle;
4297 if (pd->title().isEmpty())
4298 pageTitle=pd->name();
4299 else
4300 pageTitle = parseCommentAsText(pd,nullptr,pd->title(),pd->getDefFileName(),pd->getDefLine());
4301 QCString pageTitleAsHtml = parseCommentAsHtml(pd,nullptr,pd->title(),pd->getDefFileName(),pd->getDefLine());
4302 Doxygen::indexList->addContentsItem(
4303 hasSubPages || hasSections,
4304 pageTitle,
4305 gd->getReference(),
4306 gd->getOutputFileBase(),
4307 si ? si->label() : QCString(),
4308 hasSubPages || hasSections,
4309 TRUE,
4310 nullptr,
4311 pageTitleAsHtml); // addToNavIndex
4312 if (hasSections || hasSubPages)
4313 {
4314 Doxygen::indexList->incContentsDepth();
4315 }
4316 if (hasSections)
4317 {
4318 pd->addSectionsToIndex();
4319 }
4320 writePages(pd,nullptr);
4321 if (hasSections || hasSubPages)
4322 {
4323 Doxygen::indexList->decContentsDepth();
4324 }
4325 }
4326 }
4327 else if (lde->kind()==LayoutDocEntry::GroupNestedGroups)
4328 {
4329 if (!gd->getSubGroups().empty())
4330 {
4331 startIndexHierarchy(ol,level+1);
4332 for (const auto &subgd : gd->getSubGroups())
4333 {
4334 writeGroupTreeNode(ol,subgd,level+1,ftv,addToIndex);
4335 }
4336 endIndexHierarchy(ol,level+1);
4337 }
4338 }
4339 }
4340
4341 ol.endIndexListItem();
4342
4343 if (addToIndex)
4344 {
4345 Doxygen::indexList->decContentsDepth();
4346 }
4347 if (ftv)
4348 {
4349 ftv->decContentsDepth();
4350 }
4351 //gd->visited=TRUE;
4352 }
4353}
virtual bool isVisible() const =0
virtual const DirList & getDirs() const =0
virtual const GroupList & getSubGroups() const =0
virtual QCString groupTitle() const =0
virtual const FileList & getFiles() const =0
virtual const MemberLists & getMemberLists() const =0
virtual const ConceptLinkedRefMap & getConcepts() const =0
virtual const PageLinkedRefMap & getPages() const =0
virtual const NamespaceLinkedRefMap & getNamespaces() const =0
virtual bool isASubGroup() const =0
virtual bool isVisibleInHierarchy() const =0
virtual const ClassLinkedRefMap & getClasses() const =0
virtual MemberList * getMemberList(MemberListType lt) const =0
const T * find(const std::string &key) const
Definition linkedmap.h:47
size_t size() const
Definition linkedmap.h:375
bool empty() const
Definition linkedmap.h:374
A vector of MemberDef object.
Definition memberlist.h:35
bool empty() const noexcept
Definition memberlist.h:60
class that provide information about a section.
Definition section.h:57
QCString label() const
Definition section.h:68
static SectionManager & instance()
returns a reference to the singleton
Definition section.h:178
static void writePages(PageDef *pd, FTVHelp *ftv)
Definition index.cpp:3928
QCString parseCommentAsHtml(const Definition *scope, const MemberDef *member, const QCString &doc, const QCString &fileName, int lineNr)
Definition util.cpp:5933
QCString parseCommentAsText(const Definition *scope, const MemberDef *md, const QCString &doc, const QCString &fileName, int lineNr)
Definition util.cpp:5882

References FTVHelp::addContentsItem(), addMembersToIndex(), Config_getBool, FTVHelp::decContentsDepth(), OutputList::docify(), LinkedRefMap< T, Hash, KeyEqual, Map >::empty(), MemberVector::empty(), endIndexHierarchy(), OutputList::endIndexItem(), OutputList::endIndexListItem(), OutputList::endTypewriter(), FALSE, LinkedMap< T, Hash, KeyEqual, Map >::find(), OutputList::generateDoc(), GroupDef::getClasses(), GroupDef::getConcepts(), Definition::getDefFileName(), Definition::getDefLine(), GroupDef::getDirs(), GroupDef::getFiles(), GroupDef::getMemberList(), GroupDef::getMemberLists(), GroupDef::getNamespaces(), Definition::getOutputFileBase(), GroupDef::getPages(), Definition::getReference(), GroupDef::getSubGroups(), GroupDef::groupTitle(), FTVHelp::incContentsDepth(), Doxygen::indexList, LayoutDocManager::instance(), SectionManager::instance(), GroupDef::isASubGroup(), Definition::isReference(), Definition::isVisible(), GroupDef::isVisibleInHierarchy(), SectionInfo::label(), Definition::name(), parseCommentAsHtml(), parseCommentAsText(), LinkedRefMap< T, Hash, KeyEqual, Map >::size(), startIndexHierarchy(), OutputList::startIndexItem(), OutputList::startIndexListItem(), OutputList::startTypewriter(), TRUE, LayoutDocEntryMemberDef::type, warn, writeGroupTreeNode(), and writePages().

Referenced by writeGroupHierarchy(), and writeGroupTreeNode().

◆ writeHierarchicalExceptionIndex()

void writeHierarchicalExceptionIndex ( OutputList & ol)
static

Definition at line 1336 of file index.cpp.

1337{
1338 if (Index::instance().numHierarchyExceptions()==0) return;
1339 ol.pushGeneratorState();
1340 //1.{
1342
1343 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ExceptionHierarchy);
1344 QCString title = lne ? lne->title() : theTranslator->trExceptionHierarchy();
1345 bool addToIndex = lne==nullptr || lne->visible();
1346
1347 startFile(ol,"exceptionhierarchy",QCString(), title, HighlightedItem::ExceptionHierarchy);
1348 startTitle(ol,QCString());
1349 ol.parseText(title);
1350 endTitle(ol,QCString(),QCString());
1351 ol.startContents();
1352 ol.startTextBlock();
1353
1354 if (Config_getBool(HAVE_DOT) && Config_getBool(GRAPHICAL_HIERARCHY))
1355 {
1358 ol.startParagraph();
1359 ol.startTextLink("exceptioninherits",QCString());
1360 ol.parseText(theTranslator->trGotoGraphicalHierarchy());
1361 ol.endTextLink();
1362 ol.endParagraph();
1365 }
1366 ol.parseText(lne ? lne->intro() : theTranslator->trExceptionHierarchyDescription());
1367 ol.endTextBlock();
1368
1369 // ---------------
1370 // Static exception hierarchy for Latex/RTF
1371 // ---------------
1372 ol.pushGeneratorState();
1373 //2.{
1375 Doxygen::indexList->disable();
1376
1377 writeClassHierarchy(ol,nullptr,addToIndex,ClassDef::Exception);
1378
1379 Doxygen::indexList->enable();
1380 ol.popGeneratorState();
1381 //2.}
1382
1383 // ---------------
1384 // Dynamic exception hierarchical index for HTML
1385 // ---------------
1386 ol.pushGeneratorState();
1387 //2.{
1389
1390 {
1391 if (addToIndex)
1392 {
1393 Doxygen::indexList->addContentsItem(TRUE,title,QCString(),"exceptionhierarchy",QCString(),TRUE,TRUE);
1394 }
1395 FTVHelp ftv(false);
1396 writeClassHierarchy(ol,&ftv,addToIndex,ClassDef::Exception);
1397 TextStream t;
1398 ftv.generateTreeViewInline(t);
1399 ol.pushGeneratorState();
1401 ol.writeString(t.str().c_str());
1402 ol.popGeneratorState();
1403 }
1404 ol.popGeneratorState();
1405 //2.}
1406 // ------
1407
1408 endFile(ol);
1409 ol.popGeneratorState();
1410 //1.}
1411}
void enable(OutputType o)
static void writeClassHierarchy(OutputList &ol, FTVHelp *ftv, bool addToIndex, ClassDef::CompoundType ct)
Definition index.cpp:1063

References Config_getBool, OutputList::disable(), OutputList::disableAllBut(), OutputList::enable(), endFile(), OutputList::endParagraph(), OutputList::endTextBlock(), OutputList::endTextLink(), endTitle(), ClassDef::Exception, ExceptionHierarchy, LayoutNavEntry::find(), FTVHelp::generateTreeViewInline(), Html, Doxygen::indexList, Index::instance(), LayoutDocManager::instance(), LayoutNavEntry::intro(), Latex, Man, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), RTF, OutputList::startContents(), startFile(), OutputList::startParagraph(), OutputList::startTextBlock(), OutputList::startTextLink(), startTitle(), TextStream::str(), theTranslator, LayoutNavEntry::title(), TRUE, LayoutNavEntry::visible(), writeClassHierarchy(), and OutputList::writeString().

Referenced by writeIndexHierarchyEntries().

◆ writeHierarchicalIndex()

void writeHierarchicalIndex ( OutputList & ol)
static

Definition at line 1124 of file index.cpp.

1125{
1126 if (Index::instance().numHierarchyClasses()==0) return;
1127 ol.pushGeneratorState();
1128 //1.{
1131
1132 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassHierarchy);
1133 QCString title = lne ? lne->title() : theTranslator->trClassHierarchy();
1134 bool addToIndex = lne==nullptr || lne->visible();
1135
1136 startFile(ol,"hierarchy",QCString(), title, HighlightedItem::ClassHierarchy);
1137 startTitle(ol,QCString());
1138 ol.parseText(title);
1139 endTitle(ol,QCString(),QCString());
1140 ol.startContents();
1141 ol.startTextBlock();
1142
1143 if (Config_getBool(HAVE_DOT) && Config_getBool(GRAPHICAL_HIERARCHY))
1144 {
1145 ol.pushGeneratorState();
1149 ol.startParagraph();
1150 ol.startTextLink("inherits",QCString());
1151 ol.parseText(theTranslator->trGotoGraphicalHierarchy());
1152 ol.endTextLink();
1153 ol.endParagraph();
1154 ol.popGeneratorState();
1155 }
1156 ol.parseText(lne ? lne->intro() : theTranslator->trClassHierarchyDescription());
1157 ol.endTextBlock();
1158
1159 // ---------------
1160 // Static class hierarchy for Latex/RTF
1161 // ---------------
1162 ol.pushGeneratorState();
1163 //2.{
1165 Doxygen::indexList->disable();
1166
1167 writeClassHierarchy(ol,nullptr,addToIndex,ClassDef::Class);
1168
1169 Doxygen::indexList->enable();
1170 ol.popGeneratorState();
1171 //2.}
1172
1173 // ---------------
1174 // Dynamic class hierarchical index for HTML
1175 // ---------------
1176 ol.pushGeneratorState();
1177 //2.{
1179
1180 {
1181 if (addToIndex)
1182 {
1183 Doxygen::indexList->addContentsItem(TRUE,title,QCString(),"hierarchy",QCString(),TRUE,TRUE);
1184 }
1185 FTVHelp ftv(false);
1186 writeClassHierarchy(ol,&ftv,addToIndex,ClassDef::Class);
1187 TextStream t;
1188 ftv.generateTreeViewInline(t);
1189 ol.pushGeneratorState();
1191 ol.writeString(t.str().c_str());
1192 ol.popGeneratorState();
1193 }
1194 ol.popGeneratorState();
1195 //2.}
1196 // ------
1197
1198 endFile(ol);
1199 ol.popGeneratorState();
1200 //1.}
1201}

References ClassDef::Class, ClassHierarchy, Config_getBool, OutputList::disable(), OutputList::disableAllBut(), Docbook, endFile(), OutputList::endParagraph(), OutputList::endTextBlock(), OutputList::endTextLink(), endTitle(), LayoutNavEntry::find(), FTVHelp::generateTreeViewInline(), Html, Doxygen::indexList, Index::instance(), LayoutDocManager::instance(), LayoutNavEntry::intro(), Latex, Man, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), RTF, OutputList::startContents(), startFile(), OutputList::startParagraph(), OutputList::startTextBlock(), OutputList::startTextLink(), startTitle(), TextStream::str(), theTranslator, LayoutNavEntry::title(), TRUE, LayoutNavEntry::visible(), writeClassHierarchy(), and OutputList::writeString().

Referenced by writeIndexHierarchyEntries().

◆ writeHierarchicalInterfaceIndex()

void writeHierarchicalInterfaceIndex ( OutputList & ol)
static

Definition at line 1231 of file index.cpp.

1232{
1233 if (Index::instance().numHierarchyInterfaces()==0) return;
1234 ol.pushGeneratorState();
1235 //1.{
1237
1238 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::InterfaceHierarchy);
1239 QCString title = lne ? lne->title() : theTranslator->trInterfaceHierarchy();
1240 bool addToIndex = lne==nullptr || lne->visible();
1241
1242 startFile(ol,"interfacehierarchy",QCString(), title, HighlightedItem::InterfaceHierarchy);
1243 startTitle(ol,QCString());
1244 ol.parseText(title);
1245 endTitle(ol,QCString(),QCString());
1246 ol.startContents();
1247 ol.startTextBlock();
1248
1249 if (Config_getBool(HAVE_DOT) && Config_getBool(GRAPHICAL_HIERARCHY))
1250 {
1253 ol.startParagraph();
1254 ol.startTextLink("interfaceinherits",QCString());
1255 ol.parseText(theTranslator->trGotoGraphicalHierarchy());
1256 ol.endTextLink();
1257 ol.endParagraph();
1260 }
1261 ol.parseText(lne ? lne->intro() : theTranslator->trInterfaceHierarchyDescription());
1262 ol.endTextBlock();
1263
1264 // ---------------
1265 // Static interface hierarchy for Latex/RTF
1266 // ---------------
1267 ol.pushGeneratorState();
1268 //2.{
1270 Doxygen::indexList->disable();
1271
1272 writeClassHierarchy(ol,nullptr,addToIndex,ClassDef::Interface);
1273
1274 Doxygen::indexList->enable();
1275 ol.popGeneratorState();
1276 //2.}
1277
1278 // ---------------
1279 // Dynamic interface hierarchical index for HTML
1280 // ---------------
1281 ol.pushGeneratorState();
1282 //2.{
1284
1285 {
1286 if (addToIndex)
1287 {
1288 Doxygen::indexList->addContentsItem(TRUE,title,QCString(),"interfacehierarchy",QCString(),TRUE,TRUE);
1289 }
1290 FTVHelp ftv(false);
1291 writeClassHierarchy(ol,&ftv,addToIndex,ClassDef::Interface);
1292 TextStream t;
1293 ftv.generateTreeViewInline(t);
1294 ol.pushGeneratorState();
1296 ol.writeString(t.str().c_str());
1297 ol.popGeneratorState();
1298 }
1299 ol.popGeneratorState();
1300 //2.}
1301 // ------
1302
1303 endFile(ol);
1304 ol.popGeneratorState();
1305 //1.}
1306}

References Config_getBool, OutputList::disable(), OutputList::disableAllBut(), OutputList::enable(), endFile(), OutputList::endParagraph(), OutputList::endTextBlock(), OutputList::endTextLink(), endTitle(), LayoutNavEntry::find(), FTVHelp::generateTreeViewInline(), Html, Doxygen::indexList, Index::instance(), LayoutDocManager::instance(), ClassDef::Interface, InterfaceHierarchy, LayoutNavEntry::intro(), Latex, Man, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), RTF, OutputList::startContents(), startFile(), OutputList::startParagraph(), OutputList::startTextBlock(), OutputList::startTextLink(), startTitle(), TextStream::str(), theTranslator, LayoutNavEntry::title(), TRUE, LayoutNavEntry::visible(), writeClassHierarchy(), and OutputList::writeString().

Referenced by writeIndexHierarchyEntries().

◆ writeIndex()

void writeIndex ( OutputList & ol)
static

Definition at line 4835 of file index.cpp.

4836{
4837 bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
4838 bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
4839 bool disableIndex = Config_getBool(DISABLE_INDEX);
4840 bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
4841 bool pageOutlinePanel = Config_getBool(PAGE_OUTLINE_PANEL);
4842 bool fullSidebar = Config_getBool(FULL_SIDEBAR);
4843 QCString projectName = Config_getString(PROJECT_NAME);
4844 // save old generator state
4845 ol.pushGeneratorState();
4846
4847 QCString projPrefix;
4848 if (!projectName.isEmpty())
4849 {
4850 projPrefix=projectName+" ";
4851 }
4852
4853 //--------------------------------------------------------------------
4854 // write HTML index
4855 //--------------------------------------------------------------------
4857
4858 QCString defFileName =
4859 Doxygen::mainPage ? Doxygen::mainPage->docFile() : QCString("[generated]");
4860 int defLine =
4861 Doxygen::mainPage ? Doxygen::mainPage->docLine() : -1;
4862
4863 QCString title, titleAsHtml;
4864 if (!mainPageHasTitle())
4865 {
4866 title = theTranslator->trMainPage();
4867 }
4868 else if (Doxygen::mainPage)
4869 {
4870 title = parseCommentAsText(Doxygen::mainPage.get(),nullptr,Doxygen::mainPage->title(),
4871 Doxygen::mainPage->getDefFileName(),Doxygen::mainPage->getDefLine());
4872 titleAsHtml = parseCommentAsHtml(Doxygen::mainPage.get(),nullptr,Doxygen::mainPage->title(),
4873 Doxygen::mainPage->getDefFileName(),Doxygen::mainPage->getDefLine());
4874 }
4875
4876 QCString indexName="index";
4877 ol.startFile(indexName,QCString(),title);
4878
4880 {
4881 bool hasSubs = Doxygen::mainPage->hasSubPages() || Doxygen::mainPage->hasSections();
4882 bool hasTitle = !projectName.isEmpty() && mainPageHasTitle() && qstricmp(title,projectName)!=0;
4883 //printf("** mainPage title=%s hasTitle=%d hasSubs=%d\n",qPrint(title),hasTitle,hasSubs);
4884 if (hasTitle) // to avoid duplicate entries in the treeview
4885 {
4886 Doxygen::indexList->addContentsItem(hasSubs,
4887 title,
4888 QCString(),
4889 indexName,
4890 QCString(),
4891 hasSubs,
4892 TRUE,
4893 nullptr,
4894 titleAsHtml);
4895 }
4896 if (hasSubs)
4897 {
4898 writePages(Doxygen::mainPage.get(),nullptr);
4899 }
4900 }
4901
4902 bool quickLinksAfterSplitbar = !disableIndex && generateTreeView && fullSidebar;
4903 ol.startQuickIndices();
4904 if (!disableIndex && !quickLinksAfterSplitbar)
4905 {
4907 }
4908 ol.endQuickIndices();
4909 ol.writeSplitBar(indexName,QCString());
4910 if (quickLinksAfterSplitbar)
4911 {
4913 }
4914 ol.writeSearchInfo();
4915 bool headerWritten=FALSE;
4917 {
4918 if (!Doxygen::mainPage->title().isEmpty())
4919 {
4920 if (Doxygen::mainPage->title().lower() != "notitle")
4921 ol.startPageDoc(Doxygen::mainPage->title());
4922 else
4923 ol.startPageDoc("");
4924 }
4925 else
4926 ol.startPageDoc(projectName);
4927 }
4928 if (Doxygen::mainPage && !Doxygen::mainPage->title().isEmpty())
4929 {
4930 if (Doxygen::mainPage->title().lower()!="notitle")
4931 {
4932 ol.startHeaderSection();
4934 ol.generateDoc(Doxygen::mainPage->docFile(),Doxygen::mainPage->getStartBodyLine(),
4935 Doxygen::mainPage.get(),nullptr,Doxygen::mainPage->title(),false,false,
4936 QCString(),true,false);
4937 headerWritten = TRUE;
4938 }
4939 }
4940 else
4941 {
4942 if (!projectName.isEmpty())
4943 {
4944 ol.startHeaderSection();
4946 ol.parseText(theTranslator->trDocumentation(projectName));
4947 headerWritten = TRUE;
4948 }
4949 }
4950 if (headerWritten)
4951 {
4953 ol.endHeaderSection();
4954 }
4955
4956 ol.startContents();
4957 if (Config_getBool(DISABLE_INDEX) && Doxygen::mainPage==nullptr)
4958 {
4960 }
4961
4963 {
4964 if (Doxygen::mainPage->localToc().isHtmlEnabled() && Doxygen::mainPage->hasSections() && !(generateTreeView && pageOutlinePanel))
4965 {
4966 Doxygen::mainPage->writeToc(ol,Doxygen::mainPage->localToc());
4967 }
4968
4969 ol.startTextBlock();
4970 ol.generateDoc(defFileName,defLine,Doxygen::mainPage.get(),nullptr,
4971 Doxygen::mainPage->documentation(),true,false,
4972 QCString(),false,false);
4973 ol.endTextBlock();
4974 ol.endPageDoc();
4975 }
4976
4979 ol.writeString("<a href=\"" + fn + "\"></a>\n");
4980 Doxygen::indexList->addIndexFile(fn);
4981
4982 if (Doxygen::mainPage &&
4983 generateTreeView &&
4984 pageOutlinePanel &&
4985 Doxygen::mainPage->localToc().isHtmlEnabled() &&
4986 Doxygen::mainPage->hasSections()
4987 )
4988 {
4989 ol.writeString("</div><!-- doc-content -->\n");
4990 ol.endContents();
4991 Doxygen::mainPage->writePageNavigation(ol);
4992 ol.writeString("</div><!-- container -->\n");
4993 endFile(ol,true,true);
4994 }
4995 else
4996 {
4997 endFile(ol);
4998 }
4999
5001
5002 //--------------------------------------------------------------------
5003 // write LaTeX/RTF index
5004 //--------------------------------------------------------------------
5008
5010 {
5011 msg("Generating main page...\n");
5012 Doxygen::mainPage->writeDocumentation(ol);
5013 }
5014
5015 ol.startFile("refman",QCString(),QCString());
5019
5020 if (projPrefix.isEmpty())
5021 {
5022 ol.parseText(theTranslator->trReferenceManual());
5023 }
5024 else
5025 {
5026 ol.parseText(projPrefix);
5027 }
5028
5029 if (!Config_getString(PROJECT_NUMBER).isEmpty())
5030 {
5031 ol.startProjectNumber();
5032 ol.generateDoc(defFileName,defLine,Doxygen::mainPage.get(),nullptr,Config_getString(PROJECT_NUMBER),false,false,
5033 QCString(),false,false);
5034 ol.endProjectNumber();
5035 }
5038 ol.parseText(theTranslator->trGeneratedBy());
5042
5043 ol.lastIndexPage();
5045 {
5048 }
5049 const auto &index = Index::instance();
5050 if (index.numDocumentedPages()>0)
5051 {
5054 }
5055
5057 if (!Config_getBool(LATEX_HIDE_INDICES))
5058 {
5059 //if (indexedPages>0)
5060 //{
5061 // ol.startIndexSection(isPageIndex);
5062 // ol.parseText(/*projPrefix+*/ theTranslator->trPageIndex());
5063 // ol.endIndexSection(isPageIndex);
5064 //}
5065 if (index.numDocumentedModules()>0)
5066 {
5068 ol.parseText(/*projPrefix+*/ theTranslator->trModuleIndex());
5070 }
5071 if (index.numDocumentedGroups()>0)
5072 {
5074 ol.parseText(/*projPrefix+*/ theTranslator->trTopicIndex());
5076 }
5077 if (index.numDocumentedDirs()>0)
5078 {
5080 ol.parseText(theTranslator->trDirIndex());
5082 }
5083 if (Config_getBool(SHOW_NAMESPACES) && (index.numDocumentedNamespaces()>0))
5084 {
5085 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Namespaces);
5086 if (lne)
5087 {
5089 ol.parseText(/*projPrefix+*/(fortranOpt?theTranslator->trModulesIndex():theTranslator->trNamespaceIndex()));
5091 }
5092 }
5093 if (index.numDocumentedConcepts()>0)
5094 {
5096 ol.parseText(/*projPrefix+*/theTranslator->trConceptIndex());
5098 }
5099 if (index.numHierarchyInterfaces()>0)
5100 {
5102 ol.parseText(/*projPrefix+*/theTranslator->trHierarchicalIndex());
5104 }
5105 if (index.numHierarchyClasses()>0)
5106 {
5107 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassHierarchy);
5108 if (lne)
5109 {
5111 ol.parseText(/*projPrefix+*/
5112 (fortranOpt ? theTranslator->trCompoundIndexFortran() :
5113 vhdlOpt ? theTranslator->trHierarchicalIndex() :
5114 theTranslator->trHierarchicalIndex()
5115 ));
5117 }
5118 }
5119 if (index.numHierarchyExceptions()>0)
5120 {
5122 ol.parseText(/*projPrefix+*/theTranslator->trHierarchicalIndex());
5124 }
5125 if (index.numAnnotatedInterfacesPrinted()>0)
5126 {
5128 ol.parseText(/*projPrefix+*/theTranslator->trInterfaceIndex());
5130 }
5131 if (index.numAnnotatedClassesPrinted()>0)
5132 {
5134 ol.parseText(/*projPrefix+*/
5135 (fortranOpt ? theTranslator->trCompoundIndexFortran() :
5136 vhdlOpt ? theTranslator->trDesignUnitIndex() :
5137 theTranslator->trCompoundIndex()
5138 ));
5140 }
5141 if (index.numAnnotatedStructsPrinted()>0)
5142 {
5144 ol.parseText(/*projPrefix+*/theTranslator->trStructIndex());
5146 }
5147 if (index.numAnnotatedExceptionsPrinted()>0)
5148 {
5150 ol.parseText(/*projPrefix+*/theTranslator->trExceptionIndex());
5152 }
5153 if (Config_getBool(SHOW_FILES) && index.numDocumentedFiles()>0)
5154 {
5156 ol.parseText(/*projPrefix+*/theTranslator->trFileIndex());
5158 }
5159 }
5161
5162 if (index.numDocumentedModules()>0)
5163 {
5165 ol.parseText(/*projPrefix+*/theTranslator->trModuleDocumentation());
5167 }
5168 if (index.numDocumentedGroups()>0)
5169 {
5171 ol.parseText(/*projPrefix+*/theTranslator->trTopicDocumentation());
5173 }
5174 if (index.numDocumentedDirs()>0)
5175 {
5177 ol.parseText(/*projPrefix+*/theTranslator->trDirDocumentation());
5179 }
5180 if (index.numDocumentedNamespaces()>0)
5181 {
5183 ol.parseText(/*projPrefix+*/(fortranOpt?theTranslator->trModuleDocumentation():theTranslator->trNamespaceDocumentation()));
5185 }
5186 if (index.numDocumentedConcepts()>0)
5187 {
5189 ol.parseText(/*projPrefix+*/theTranslator->trConceptDocumentation());
5191 }
5192 if (index.numAnnotatedInterfacesPrinted()>0)
5193 {
5195 ol.parseText(/*projPrefix+*/theTranslator->trInterfaceDocumentation());
5197 }
5198 if (index.numAnnotatedClassesPrinted()>0)
5199 {
5201 ol.parseText(/*projPrefix+*/(fortranOpt?theTranslator->trTypeDocumentation():theTranslator->trClassDocumentation()));
5203 }
5204 if (index.numAnnotatedStructsPrinted()>0)
5205 {
5207 ol.parseText(/*projPrefix+*/theTranslator->trStructDocumentation());
5209 }
5210 if (index.numAnnotatedExceptionsPrinted()>0)
5211 {
5213 ol.parseText(/*projPrefix+*/theTranslator->trExceptionDocumentation());
5215 }
5216 if (Config_getBool(SHOW_FILES) && index.numDocumentedFiles()>0)
5217 {
5219 ol.parseText(/*projPrefix+*/theTranslator->trFileDocumentation());
5221 }
5222 if (!Doxygen::exampleLinkedMap->empty())
5223 {
5225 ol.parseText(/*projPrefix+*/theTranslator->trExamples());
5227 }
5229 endFile(ol);
5230
5231 ol.popGeneratorState();
5232}
static const QCString crawlFileName
Definition sitemap.h:75
void endPageDoc()
Definition outputlist.h:626
void endIndexSection(IndexSection is)
Definition outputlist.h:389
void startProjectNumber()
Definition outputlist.h:393
void lastIndexPage()
Definition outputlist.h:676
void startPageDoc(const QCString &pageTitle)
Definition outputlist.h:624
void endProjectNumber()
Definition outputlist.h:395
void startIndexSection(IndexSection is)
Definition outputlist.h:387
@ isMainPage
Definition index.h:35
@ isTitlePageAuthor
Definition index.h:34
@ isFileIndex
Definition index.h:43
@ isFileDocumentation
Definition index.h:51
@ isPageDocumentation
Definition index.h:53
@ isDirDocumentation
Definition index.h:47
@ isModuleDocumentation
Definition index.h:45
@ isClassHierarchyIndex
Definition index.h:41
@ isModuleIndex
Definition index.h:36
@ isTopicIndex
Definition index.h:37
@ isConceptIndex
Definition index.h:40
@ isExampleDocumentation
Definition index.h:52
@ isClassDocumentation
Definition index.h:49
@ isCompoundIndex
Definition index.h:42
@ isEndIndex
Definition index.h:55
@ isConceptDocumentation
Definition index.h:50
@ isDirIndex
Definition index.h:38
@ isNamespaceIndex
Definition index.h:39
@ isNamespaceDocumentation
Definition index.h:48
@ isTitlePageStart
Definition index.h:33
@ isTopicDocumentation
Definition index.h:46
#define msg(fmt,...)
Definition message.h:94
void addHtmlExtensionIfMissing(QCString &fName)
Definition util.cpp:5418

References addHtmlExtensionIfMissing(), Config_getBool, Config_getString, Crawlmap::crawlFileName, OutputList::disable(), OutputList::disableAllBut(), Docbook, OutputList::enable(), OutputList::endContents(), endFile(), OutputList::endHeaderSection(), OutputList::endIndexSection(), OutputList::endPageDoc(), OutputList::endProjectNumber(), OutputList::endQuickIndices(), OutputList::endTextBlock(), OutputList::endTitleHead(), Doxygen::exampleLinkedMap, FALSE, LayoutNavEntry::find(), OutputList::generateDoc(), Html, Doxygen::indexList, Index::instance(), LayoutDocManager::instance(), isClassDocumentation, isClassHierarchyIndex, isCompoundIndex, isConceptDocumentation, isConceptIndex, isDirDocumentation, isDirIndex, QCString::isEmpty(), isEndIndex, isExampleDocumentation, isFileDocumentation, isFileIndex, isMainPage, isModuleDocumentation, isModuleIndex, isNamespaceDocumentation, isNamespaceIndex, isPageDocumentation, isTitlePageAuthor, isTitlePageStart, isTopicDocumentation, isTopicIndex, OutputList::lastIndexPage(), Latex, Main, Doxygen::mainPage, mainPageHasTitle(), msg, parseCommentAsHtml(), parseCommentAsText(), OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), qstricmp(), LayoutDocManager::rootNavEntry(), RTF, OutputList::startContents(), OutputList::startFile(), OutputList::startHeaderSection(), OutputList::startIndexSection(), OutputList::startPageDoc(), OutputList::startProjectNumber(), OutputList::startQuickIndices(), OutputList::startTextBlock(), OutputList::startTitleHead(), theTranslator, TRUE, writePages(), OutputList::writeQuickLinks(), OutputList::writeSearchInfo(), OutputList::writeSplitBar(), and OutputList::writeString().

Referenced by writeIndexHierarchyEntries().

◆ writeIndexHierarchy()

void writeIndexHierarchy ( OutputList & ol)

Definition at line 5758 of file index.cpp.

5759{
5760 writeMenuData();
5762 if (lne)
5763 {
5765 }
5766}
static void writeIndexHierarchyEntries(OutputList &ol, const LayoutNavEntryList &entries)
Definition index.cpp:5236
static void writeMenuData()
Definition index.cpp:5742

References LayoutNavEntry::children(), LayoutDocManager::instance(), LayoutDocManager::rootNavEntry(), writeIndexHierarchyEntries(), and writeMenuData().

Referenced by generateOutput().

◆ writeIndexHierarchyEntries()

void writeIndexHierarchyEntries ( OutputList & ol,
const LayoutNavEntryList & entries )
static

Definition at line 5236 of file index.cpp.

5237{
5238 auto isRef = [](const QCString &s)
5239 {
5240 return s.startsWith("@ref") || s.startsWith("\\ref");
5241 };
5242 bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
5243 const auto &index = Index::instance();
5244 for (const auto &lne : entries)
5245 {
5246 LayoutNavEntry::Kind kind = lne->kind();
5247 size_t idx = static_cast<size_t>(kind);
5248 if (idx>=indexWritten.size())
5249 {
5250 size_t oldSize = indexWritten.size();
5251 size_t newSize = idx+1;
5252 indexWritten.resize(newSize);
5253 for (size_t i=oldSize; i<newSize; i++) indexWritten.at(i)=FALSE;
5254 }
5255 //printf("starting %s kind=%d\n",qPrint(lne->title()),lne->kind());
5256 bool addToIndex=lne->visible();
5257 bool needsClosing=FALSE;
5258 if (!indexWritten.at(idx))
5259 {
5260 switch(kind)
5261 {
5262 case LayoutNavEntry::MainPage:
5263 msg("Generating index page...\n");
5264 writeIndex(ol);
5265 break;
5266 case LayoutNavEntry::Pages:
5267 msg("Generating page index...\n");
5268 writePageIndex(ol);
5269 break;
5270 case LayoutNavEntry::Topics:
5271 msg("Generating topic index...\n");
5272 writeTopicIndex(ol);
5273 break;
5274 case LayoutNavEntry::Modules:
5275 {
5276 if (index.numDocumentedModules()>0 && addToIndex)
5277 {
5278 Doxygen::indexList->addContentsItem(TRUE,lne->title(),QCString(),lne->baseFile(),QCString());
5279 Doxygen::indexList->incContentsDepth();
5280 needsClosing=TRUE;
5281 }
5282 }
5283 break;
5284 case LayoutNavEntry::ModuleList:
5285 msg("Generating module index...\n");
5286 writeModuleIndex(ol);
5287 break;
5288 case LayoutNavEntry::ModuleMembers:
5289 msg("Generating module member index...\n");
5291 break;
5292 case LayoutNavEntry::Namespaces:
5293 {
5294 bool showNamespaces = Config_getBool(SHOW_NAMESPACES);
5295 if (showNamespaces)
5296 {
5297 if (index.numDocumentedNamespaces()>0 && addToIndex)
5298 {
5299 Doxygen::indexList->addContentsItem(TRUE,lne->title(),QCString(),lne->baseFile(),QCString());
5300 Doxygen::indexList->incContentsDepth();
5301 needsClosing=TRUE;
5302 }
5303 if (LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Namespaces)!=lne.get()) // for backward compatibility with old layout file
5304 {
5305 msg("Generating namespace index...\n");
5307 }
5308 }
5309 }
5310 break;
5311 case LayoutNavEntry::NamespaceList:
5312 {
5313 bool showNamespaces = Config_getBool(SHOW_NAMESPACES);
5314 if (showNamespaces)
5315 {
5316 msg("Generating namespace index...\n");
5318 }
5319 }
5320 break;
5321 case LayoutNavEntry::NamespaceMembers:
5322 msg("Generating namespace member index...\n");
5324 break;
5325 case LayoutNavEntry::Classes:
5326 if (index.numAnnotatedClasses()>0 && addToIndex)
5327 {
5328 Doxygen::indexList->addContentsItem(TRUE,lne->title(),QCString(),lne->baseFile(),QCString());
5329 Doxygen::indexList->incContentsDepth();
5330 needsClosing=TRUE;
5331 }
5332 if (LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Classes)!=lne.get()) // for backward compatibility with old layout file
5333 {
5334 msg("Generating annotated compound index...\n");
5336 }
5337 break;
5338 case LayoutNavEntry::Concepts:
5339 msg("Generating concept index...\n");
5341 break;
5342 case LayoutNavEntry::ClassList:
5343 msg("Generating annotated compound index...\n");
5345 break;
5346 case LayoutNavEntry::ClassIndex:
5347 msg("Generating alphabetical compound index...\n");
5349 break;
5350 case LayoutNavEntry::ClassHierarchy:
5351 msg("Generating hierarchical class index...\n");
5353 if (Config_getBool(HAVE_DOT) && Config_getBool(GRAPHICAL_HIERARCHY))
5354 {
5355 msg("Generating graphical class hierarchy...\n");
5357 }
5358 break;
5359 case LayoutNavEntry::ClassMembers:
5360 if (!sliceOpt)
5361 {
5362 msg("Generating member index...\n");
5364 }
5365 break;
5366 case LayoutNavEntry::Interfaces:
5367 if (sliceOpt && index.numAnnotatedInterfaces()>0 && addToIndex)
5368 {
5369 Doxygen::indexList->addContentsItem(TRUE,lne->title(),QCString(),lne->baseFile(),QCString());
5370 Doxygen::indexList->incContentsDepth();
5371 needsClosing=TRUE;
5372 }
5373 break;
5374 case LayoutNavEntry::InterfaceList:
5375 if (sliceOpt)
5376 {
5377 msg("Generating annotated interface index...\n");
5379 }
5380 break;
5381 case LayoutNavEntry::InterfaceIndex:
5382 if (sliceOpt)
5383 {
5384 msg("Generating alphabetical interface index...\n");
5386 }
5387 break;
5388 case LayoutNavEntry::InterfaceHierarchy:
5389 if (sliceOpt)
5390 {
5391 msg("Generating hierarchical interface index...\n");
5393 if (Config_getBool(HAVE_DOT) && Config_getBool(GRAPHICAL_HIERARCHY))
5394 {
5395 msg("Generating graphical interface hierarchy...\n");
5397 }
5398 }
5399 break;
5400 case LayoutNavEntry::Structs:
5401 if (sliceOpt && index.numAnnotatedStructs()>0 && addToIndex)
5402 {
5403 Doxygen::indexList->addContentsItem(TRUE,lne->title(),QCString(),lne->baseFile(),QCString());
5404 Doxygen::indexList->incContentsDepth();
5405 needsClosing=TRUE;
5406 }
5407 break;
5408 case LayoutNavEntry::StructList:
5409 if (sliceOpt)
5410 {
5411 msg("Generating annotated struct index...\n");
5413 }
5414 break;
5415 case LayoutNavEntry::StructIndex:
5416 if (sliceOpt)
5417 {
5418 msg("Generating alphabetical struct index...\n");
5420 }
5421 break;
5422 case LayoutNavEntry::Exceptions:
5423 if (sliceOpt && index.numAnnotatedExceptions()>0 && addToIndex)
5424 {
5425 Doxygen::indexList->addContentsItem(TRUE,lne->title(),QCString(),lne->baseFile(),QCString());
5426 Doxygen::indexList->incContentsDepth();
5427 needsClosing=TRUE;
5428 }
5429 break;
5430 case LayoutNavEntry::ExceptionList:
5431 if (sliceOpt)
5432 {
5433 msg("Generating annotated exception index...\n");
5435 }
5436 break;
5437 case LayoutNavEntry::ExceptionIndex:
5438 if (sliceOpt)
5439 {
5440 msg("Generating alphabetical exception index...\n");
5442 }
5443 break;
5444 case LayoutNavEntry::ExceptionHierarchy:
5445 if (sliceOpt)
5446 {
5447 msg("Generating hierarchical exception index...\n");
5449 if (Config_getBool(HAVE_DOT) && Config_getBool(GRAPHICAL_HIERARCHY))
5450 {
5451 msg("Generating graphical exception hierarchy...\n");
5453 }
5454 }
5455 break;
5456 case LayoutNavEntry::Files:
5457 {
5458 if (Config_getBool(SHOW_FILES) && index.numDocumentedFiles()>0 && addToIndex)
5459 {
5460 Doxygen::indexList->addContentsItem(TRUE,lne->title(),QCString(),lne->baseFile(),QCString());
5461 Doxygen::indexList->incContentsDepth();
5462 needsClosing=TRUE;
5463 }
5464 if (LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Files)!=lne.get()) // for backward compatibility with old layout file
5465 {
5466 msg("Generating file index...\n");
5467 writeFileIndex(ol);
5468 }
5469 }
5470 break;
5471 case LayoutNavEntry::FileList:
5472 msg("Generating file index...\n");
5473 writeFileIndex(ol);
5474 break;
5475 case LayoutNavEntry::FileGlobals:
5476 msg("Generating file member index...\n");
5478 break;
5479 case LayoutNavEntry::Examples:
5480 msg("Generating example index...\n");
5482 break;
5483 case LayoutNavEntry::User:
5484 if (addToIndex)
5485 {
5486 // prepend a ! or ^ marker to the URL to avoid tampering with it
5487 QCString url = correctURL(lne->url(),"!"); // add ! to relative URL
5488 bool isRelative=url.at(0)=='!';
5489 if (!url.isEmpty() && !isRelative) // absolute URL
5490 {
5491 url.prepend("^"); // prepend ^ to absolute URL
5492 }
5493 Doxygen::indexList->addContentsItem(TRUE,lne->title(),QCString(),
5494 url,QCString(),FALSE,isRef(lne->baseFile()) || isRelative);
5495 }
5496 break;
5497 case LayoutNavEntry::UserGroup:
5498 if (addToIndex)
5499 {
5500 QCString url = correctURL(lne->url(),"!"); // add ! to relative URL
5501 if (!url.isEmpty())
5502 {
5503 if (url=="!") // result of a "[none]" url
5504 {
5505 Doxygen::indexList->addContentsItem(TRUE,lne->title(),QCString(),QCString(),QCString(),FALSE,FALSE);
5506 }
5507 else
5508 {
5509 bool isRelative=url.at(0)=='!';
5510 if (!isRelative) // absolute URL
5511 {
5512 url.prepend("^"); // prepend ^ to absolute URL
5513 }
5514 Doxygen::indexList->addContentsItem(TRUE,lne->title(),QCString(),
5515 url,QCString(),FALSE,isRef(lne->baseFile()) || isRelative);
5516 }
5517 }
5518 else
5519 {
5520 Doxygen::indexList->addContentsItem(TRUE,lne->title(),QCString(),lne->baseFile(),QCString(),TRUE,TRUE);
5521 }
5522 Doxygen::indexList->incContentsDepth();
5523 needsClosing=TRUE;
5524 }
5525 writeUserGroupStubPage(ol,lne.get());
5526 break;
5527 case LayoutNavEntry::None:
5528 assert(kind != LayoutNavEntry::None); // should never happen, means not properly initialized
5529 break;
5530 }
5531 if (kind!=LayoutNavEntry::User && kind!=LayoutNavEntry::UserGroup) // User entry may appear multiple times
5532 {
5533 indexWritten.at(idx)=TRUE;
5534 }
5535 }
5536 writeIndexHierarchyEntries(ol,lne->children());
5537 if (needsClosing)
5538 {
5539 switch(kind)
5540 {
5541 case LayoutNavEntry::Modules:
5542 case LayoutNavEntry::Namespaces:
5543 case LayoutNavEntry::Classes:
5544 case LayoutNavEntry::Files:
5545 case LayoutNavEntry::UserGroup:
5546 Doxygen::indexList->decContentsDepth();
5547 break;
5548 default:
5549 break;
5550 }
5551 }
5552 //printf("ending %s kind=%d\n",qPrint(lne->title()),lne->kind());
5553 }
5554
5555 // always write the directory index as it is used for non-HTML output only
5556 writeDirIndex(ol);
5557}
QCString & prepend(const char *s)
Definition qcstring.h:407
char & at(size_t i)
Returns a reference to the character at index i.
Definition qcstring.h:578
static void writeGraphicalClassHierarchy(OutputList &ol)
Definition index.cpp:1205
static void writeAnnotatedStructIndex(OutputList &ol)
Definition index.cpp:2680
static void writeAlphabeticalExceptionIndex(OutputList &ol)
Definition index.cpp:2523
static void writeDirIndex(OutputList &ol)
Definition index.cpp:1541
static void writeClassMemberIndex(OutputList &ol)
Definition index.cpp:3261
static std::vector< bool > indexWritten
Definition index.cpp:5234
static void writeAnnotatedIndex(OutputList &ol)
Definition index.cpp:2652
static void writeFileIndex(OutputList &ol)
Definition index.cpp:1570
static void writeGraphicalInterfaceHierarchy(OutputList &ol)
Definition index.cpp:1310
static void writeAlphabeticalIndex(OutputList &ol)
Definition index.cpp:2436
static void writeAnnotatedInterfaceIndex(OutputList &ol)
Definition index.cpp:2666
static void writePageIndex(OutputList &ol)
Definition index.cpp:3989
static void writeNamespaceIndex(OutputList &ol)
Definition index.cpp:2023
static void writeAnnotatedExceptionIndex(OutputList &ol)
Definition index.cpp:2694
static void writeHierarchicalInterfaceIndex(OutputList &ol)
Definition index.cpp:1231
static void writeUserGroupStubPage(OutputList &ol, LayoutNavEntry *lne)
Definition index.cpp:4798
static void writeTopicIndex(OutputList &ol)
Definition index.cpp:4379
static void writeModuleMemberIndex(OutputList &ol)
Definition index.cpp:3809
static void writeGraphicalExceptionHierarchy(OutputList &ol)
Definition index.cpp:1415
static void writeExampleIndex(OutputList &ol)
Definition index.cpp:3834
static void writeAlphabeticalInterfaceIndex(OutputList &ol)
Definition index.cpp:2465
static void writeAlphabeticalStructIndex(OutputList &ol)
Definition index.cpp:2494
static void writeConceptIndex(OutputList &ol)
Definition index.cpp:4693
static void writeModuleIndex(OutputList &ol)
Definition index.cpp:4519
static void writeIndex(OutputList &ol)
Definition index.cpp:4835
static void writeHierarchicalExceptionIndex(OutputList &ol)
Definition index.cpp:1336
static void writeNamespaceMemberIndex(OutputList &ol)
Definition index.cpp:3629
static void writeHierarchicalIndex(OutputList &ol)
Definition index.cpp:1124
static void writeFileMemberIndex(OutputList &ol)
Definition index.cpp:3445
Kind
Definition layout.h:193
QCString correctURL(const QCString &url, const QCString &relPath)
Corrects URL url according to the relative path relPath.
Definition util.cpp:6444

References QCString::at(), Config_getBool, correctURL(), FALSE, Doxygen::indexList, indexWritten, Index::instance(), LayoutDocManager::instance(), QCString::isEmpty(), msg, QCString::prepend(), TRUE, writeAlphabeticalExceptionIndex(), writeAlphabeticalIndex(), writeAlphabeticalInterfaceIndex(), writeAlphabeticalStructIndex(), writeAnnotatedExceptionIndex(), writeAnnotatedIndex(), writeAnnotatedInterfaceIndex(), writeAnnotatedStructIndex(), writeClassMemberIndex(), writeConceptIndex(), writeDirIndex(), writeExampleIndex(), writeFileIndex(), writeFileMemberIndex(), writeGraphicalClassHierarchy(), writeGraphicalExceptionHierarchy(), writeGraphicalInterfaceHierarchy(), writeHierarchicalExceptionIndex(), writeHierarchicalIndex(), writeHierarchicalInterfaceIndex(), writeIndex(), writeIndexHierarchyEntries(), writeModuleIndex(), writeModuleMemberIndex(), writeNamespaceIndex(), writeNamespaceMemberIndex(), writePageIndex(), writeTopicIndex(), and writeUserGroupStubPage().

Referenced by writeIndexHierarchy(), and writeIndexHierarchyEntries().

◆ writeMemberList()

void writeMemberList ( OutputList & ol,
bool useSections,
const std::string & page,
const Index::MemberIndexMap & memberIndexMap,
Definition::DefType type )
static

Definition at line 2761 of file index.cpp.

2764{
2765 int index = static_cast<int>(type);
2766 const int numIndices = 4;
2767 ASSERT(index<numIndices);
2768
2769 typedef void (*writeLinkForMember_t)(OutputList &ol,const MemberDef *md,const QCString &separator,
2770 QCString &prevNamespaceName);
2771
2772 // each index tab has its own write function
2773 static writeLinkForMember_t writeLinkForMemberMap[numIndices] =
2774 {
2779 };
2780 QCString prevName;
2781 QCString prevDefName;
2782 bool first=TRUE;
2783 bool firstSection=TRUE;
2784 bool firstItem=TRUE;
2785 const Index::MemberIndexList *mil = nullptr;
2786 std::string letter;
2787 for (const auto &kv : memberIndexMap)
2788 {
2789 if (!page.empty()) // specific page mode
2790 {
2791 auto it = memberIndexMap.find(page);
2792 if (it != memberIndexMap.end())
2793 {
2794 mil = &it->second;
2795 letter = page;
2796 }
2797 }
2798 else // do all pages
2799 {
2800 mil = &kv.second;
2801 letter = kv.first;
2802 }
2803 if (mil==nullptr || mil->empty()) continue;
2804 for (const auto &md : *mil)
2805 {
2806 const char *sep = nullptr;
2807 bool isFunc=!md->isObjCMethod() &&
2808 (md->isFunction() || md->isSlot() || md->isSignal());
2809 QCString name=type==Definition::TypeModule ? md->qualifiedName() : md->name();
2810 int startIndex = getPrefixIndex(name);
2811 if (name.data()+startIndex!=prevName) // new entry
2812 {
2813 if ((prevName.isEmpty() ||
2814 tolower(name.at(startIndex))!=tolower(prevName.at(0))) &&
2815 useSections) // new section
2816 {
2817 if (!firstItem) ol.endItemListItem();
2818 if (!firstSection) ol.endItemList();
2819 QCString cs = letterToLabel(letter.c_str());
2820 QCString anchor=QCString("index_")+convertToId(cs);
2821 QCString title=QCString("- ")+letter.c_str()+" -";
2822 ol.startSection(anchor,title,SectionType::Subsection);
2823 ol.docify(title);
2824 ol.endSection(anchor,SectionType::Subsection);
2825 ol.startItemList();
2826 firstSection=FALSE;
2827 firstItem=TRUE;
2828 }
2829 else if (!useSections && first)
2830 {
2831 ol.startItemList();
2832 first=FALSE;
2833 }
2834
2835 // member name
2836 if (!firstItem) ol.endItemListItem();
2837 ol.startItemListItem();
2838 firstItem=FALSE;
2839 ol.docify(name);
2840 if (isFunc) ol.docify("()");
2841 //ol.writeString("\n");
2842
2843 // link to class
2844 prevDefName="";
2845 sep = "&#160;:&#160;";
2846 prevName = name.data()+startIndex;
2847 }
2848 else // same entry
2849 {
2850 sep = ", ";
2851 // link to class for other members with the same name
2852 }
2853 if (index<numIndices)
2854 {
2855 // write the link for the specific list type
2856 writeLinkForMemberMap[index](ol,md,sep,prevDefName);
2857 }
2858 }
2859 if (!page.empty())
2860 {
2861 break;
2862 }
2863 }
2864 if (!firstItem) ol.endItemListItem();
2865 ol.endItemList();
2866}
std::vector< const MemberDef * > MemberIndexList
Definition index.h:167
A model of a class/file/namespace member symbol.
Definition memberdef.h:48
Class representing a list of output generators that are written to in parallel.
Definition outputlist.h:314
static constexpr int Subsection
Definition section.h:34
static void writeFileLinkForMember(OutputList &ol, const MemberDef *md, const QCString &separator, QCString &prevFileName)
Definition index.cpp:2720
static void writeNamespaceLinkForMember(OutputList &ol, const MemberDef *md, const QCString &separator, QCString &prevNamespaceName)
Definition index.cpp:2733
static void writeClassLinkForMember(OutputList &ol, const MemberDef *md, const QCString &separator, QCString &prevClassName)
Definition index.cpp:2707
static void writeModuleLinkForMember(OutputList &ol, const MemberDef *md, const QCString &separator, QCString &prevModuleName)
Definition index.cpp:2746
#define ASSERT(x)
Definition qcstring.h:39

References ASSERT, QCString::at(), convertToId(), QCString::data(), OutputList::docify(), OutputList::endItemList(), OutputList::endItemListItem(), OutputList::endSection(), FALSE, getPrefixIndex(), QCString::isEmpty(), letterToLabel(), OutputList::startItemList(), OutputList::startItemListItem(), OutputList::startSection(), SectionType::Subsection, TRUE, Definition::TypeModule, writeClassLinkForMember(), writeFileLinkForMember(), writeModuleLinkForMember(), and writeNamespaceLinkForMember().

Referenced by writeClassMemberIndexFiltered(), writeFileMemberIndexFiltered(), writeModuleMemberIndexFiltered(), and writeNamespaceMemberIndexFiltered().

◆ writeMemberToIndex()

void writeMemberToIndex ( const Definition * def,
const MemberDef * md,
bool addToIndex )
static

Definition at line 468 of file index.cpp.

469{
470 bool isAnonymous = md->isAnonymous();
471 bool hideUndocMembers = Config_getBool(HIDE_UNDOC_MEMBERS);
472 const MemberVector &enumList = md->enumFieldList();
473 bool isDir = !enumList.empty() && md->isEnumerate();
474 auto defType = def->definitionType();
475 bool namespaceMemberInFileDocs = md->getNamespaceDef() && defType==Definition::TypeFile;
476 bool lAddToIndex = addToIndex && !namespaceMemberInFileDocs;
477 QCString name = namespaceMemberInFileDocs || defType==Definition::TypeModule ?
478 md->qualifiedName() : md->name();
479 if (md->getOuterScope()==def ||
480 (md->getNamespaceDef()!=nullptr && defType==Definition::TypeFile) ||
482 {
483 Doxygen::indexList->addContentsItem(isDir,
484 name,md->getReference(),md->getOutputFileBase(),md->anchor(),FALSE,lAddToIndex && md->getGroupDef()==nullptr);
485 }
486 else // inherited member
487 {
488 Doxygen::indexList->addContentsItem(isDir,
489 name,def->getReference(),def->getOutputFileBase(),md->anchor(),FALSE,lAddToIndex && md->getGroupDef()==nullptr);
490 }
491 if (isDir)
492 {
493 if (!isAnonymous)
494 {
495 Doxygen::indexList->incContentsDepth();
496 }
497 for (const auto &emd : enumList)
498 {
499 if (!hideUndocMembers || emd->hasDocumentation())
500 {
501 namespaceMemberInFileDocs = emd->getNamespaceDef() && defType==Definition::TypeFile;
502 lAddToIndex = addToIndex && !namespaceMemberInFileDocs;
503 QCString ename = namespaceMemberInFileDocs || defType==Definition::TypeModule ?
504 emd->qualifiedName() : emd->name();
505 if (emd->getOuterScope()==def ||
506 (emd->getNamespaceDef()!=nullptr && defType==Definition::TypeFile) ||
507 emd->getOuterScope()==Doxygen::globalScope)
508 {
509 Doxygen::indexList->addContentsItem(FALSE,
510 ename,emd->getReference(),emd->getOutputFileBase(),emd->anchor(),FALSE,lAddToIndex && emd->getGroupDef()==nullptr);
511 }
512 else // inherited member
513 {
514 Doxygen::indexList->addContentsItem(FALSE,
515 ename,def->getReference(),def->getOutputFileBase(),emd->anchor(),FALSE,lAddToIndex && emd->getGroupDef()==nullptr);
516 }
517 }
518 }
519 if (!isAnonymous)
520 {
521 Doxygen::indexList->decContentsDepth();
522 }
523 }
524}
virtual QCString qualifiedName() const =0
virtual GroupDef * getGroupDef()=0
virtual const MemberVector & enumFieldList() const =0
virtual const NamespaceDef * getNamespaceDef() const =0
virtual bool isEnumerate() const =0

References Definition::anchor(), Config_getBool, Definition::definitionType(), MemberVector::empty(), MemberDef::enumFieldList(), FALSE, MemberDef::getGroupDef(), MemberDef::getNamespaceDef(), Definition::getOuterScope(), Definition::getOutputFileBase(), Definition::getReference(), Doxygen::globalScope, Doxygen::indexList, Definition::isAnonymous(), MemberDef::isEnumerate(), Definition::name(), Definition::qualifiedName(), Definition::TypeFile, and Definition::TypeModule.

Referenced by addMembersToIndex(), writeModuleMembers(), and writeNamespaceMembers().

◆ writeMenuData()

void writeMenuData ( )
static

Definition at line 5742 of file index.cpp.

5743{
5744 if (!Config_getBool(GENERATE_HTML) || Config_getBool(DISABLE_INDEX)) return;
5745 QCString outputDir = Config_getBool(HTML_OUTPUT);
5747 std::ofstream t = Portable::openOutputStream(outputDir+"/menudata.js");
5748 if (t.is_open())
5749 {
5751 t << "var menudata={";
5752 bool hasChildren = renderQuickLinksAsJs(t,root,TRUE);
5753 if (hasChildren) t << "]";
5754 t << "}\n";
5755 }
5756}
constexpr auto JAVASCRIPT_LICENSE_TEXT
Definition ftvhelp.h:72
std::ofstream openOutputStream(const QCString &name, bool append=false)
Definition portable.cpp:665

References Config_getBool, LayoutDocManager::instance(), JAVASCRIPT_LICENSE_TEXT, Portable::openOutputStream(), renderQuickLinksAsJs(), LayoutDocManager::rootNavEntry(), and TRUE.

Referenced by writeIndexHierarchy().

◆ writeModuleIndex()

void writeModuleIndex ( OutputList & ol)
static

Definition at line 4519 of file index.cpp.

4520{
4521 if (ModuleManager::instance().numDocumentedModules()==0) return;
4522 ol.pushGeneratorState();
4523 // 1.{
4524
4527 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ModuleList);
4528 if (lne==nullptr) lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Modules); // fall back
4529 QCString title = lne ? lne->title() : theTranslator->trModules();
4530 bool addToIndex = lne==nullptr || lne->visible();
4531
4532 startFile(ol,"modules",QCString(),title,HighlightedItem::Modules);
4533 startTitle(ol,QCString());
4534 ol.parseText(title);
4535 endTitle(ol,QCString(),QCString());
4536 ol.startContents();
4537 ol.startTextBlock();
4538 ol.parseText(lne ? lne->intro() : theTranslator->trModulesListDescription(Config_getBool(EXTRACT_ALL)));
4539 ol.endTextBlock();
4540
4541 // ---------------
4542 // Normal group index for Latex/RTF
4543 // ---------------
4544 // 2.{
4545 ol.pushGeneratorState();
4547 Doxygen::indexList->disable();
4548
4549 writeModuleList(ol,nullptr,FALSE);
4550
4551 Doxygen::indexList->enable();
4552 ol.popGeneratorState();
4553 // 2.}
4554
4555 // ---------------
4556 // interactive group index for HTML
4557 // ---------------
4558 // 2.{
4559 ol.pushGeneratorState();
4561
4562 {
4563 if (addToIndex)
4564 {
4565 Doxygen::indexList->addContentsItem(TRUE,title,QCString(),"modules",QCString(),TRUE,TRUE);
4566 Doxygen::indexList->incContentsDepth();
4567 }
4568 FTVHelp ftv(false);
4569 writeModuleList(ol,&ftv,addToIndex);
4570 TextStream t;
4571 ftv.generateTreeViewInline(t);
4572 ol.writeString(t.str().c_str());
4573 if (addToIndex)
4574 {
4575 Doxygen::indexList->decContentsDepth();
4576 }
4577 }
4578 ol.popGeneratorState();
4579 // 2.}
4580 endFile(ol);
4581 ol.popGeneratorState();
4582 // 1.}
4583}
static ModuleManager & instance()
static void writeModuleList(OutputList &ol, FTVHelp *ftv, bool addToIndex)
Definition index.cpp:4495

References Config_getBool, OutputList::disable(), OutputList::disableAllBut(), Docbook, endFile(), OutputList::endTextBlock(), endTitle(), FALSE, LayoutNavEntry::find(), FTVHelp::generateTreeViewInline(), Html, Doxygen::indexList, LayoutDocManager::instance(), ModuleManager::instance(), LayoutNavEntry::intro(), Man, Modules, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), startFile(), OutputList::startTextBlock(), startTitle(), TextStream::str(), theTranslator, LayoutNavEntry::title(), TRUE, LayoutNavEntry::visible(), writeModuleList(), and OutputList::writeString().

Referenced by writeIndexHierarchyEntries().

◆ writeModuleLinkForMember()

void writeModuleLinkForMember ( OutputList & ol,
const MemberDef * md,
const QCString & separator,
QCString & prevModuleName )
static

Definition at line 2746 of file index.cpp.

2748{
2749 const ModuleDef *mod=md->getModuleDef();
2750 if (mod && prevModuleName!=mod->displayName())
2751 {
2752 ol.writeString(separator);
2753 // link to the member declaration in the module page
2754 ol.writeObjectLink(mod->getReference(),mod->getOutputFileBase(),"r_"+md->anchor(),
2755 mod->displayName());
2756 prevModuleName = mod->displayName();
2757 }
2758}
virtual const ModuleDef * getModuleDef() const =0

References Definition::anchor(), Definition::displayName(), MemberDef::getModuleDef(), Definition::getOutputFileBase(), Definition::getReference(), OutputList::writeObjectLink(), and OutputList::writeString().

Referenced by writeMemberList().

◆ writeModuleList()

void writeModuleList ( OutputList & ol,
FTVHelp * ftv,
bool addToIndex )
static

Definition at line 4495 of file index.cpp.

4496{
4497 if (ftv)
4498 {
4499 ol.pushGeneratorState();
4501 }
4502 startIndexHierarchy(ol,0);
4503 for (const auto &mod : ModuleManager::instance().modules())
4504 {
4505 if (mod->isPrimaryInterface())
4506 {
4507 writeModuleTreeNode(ol,mod.get(),ftv,addToIndex);
4508 }
4509 }
4510 endIndexHierarchy(ol,0);
4511 if (ftv)
4512 {
4513 ol.popGeneratorState();
4514 }
4515}
static void writeModuleTreeNode(OutputList &ol, const ModuleDef *mod, FTVHelp *ftv, bool addToIndex)
Definition index.cpp:4448

References OutputList::disable(), endIndexHierarchy(), Html, ModuleManager::instance(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), startIndexHierarchy(), and writeModuleTreeNode().

Referenced by writeModuleIndex().

◆ writeModuleMemberIndex()

void writeModuleMemberIndex ( OutputList & ol)
static

Definition at line 3809 of file index.cpp.

3810{
3811 const auto &index = Index::instance();
3812 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ModuleMembers);
3813 bool addToIndex = lne==nullptr || lne->visible();
3814 if (index.numDocumentedModuleMembers(ModuleMemberHighlight::All)>0 && addToIndex)
3815 {
3816 Doxygen::indexList->addContentsItem(true,lne ? lne->title() : theTranslator->trModulesMembers(),QCString(),"modulemembers",QCString());
3817 Doxygen::indexList->incContentsDepth();
3818 }
3819 //bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
3826 if (index.numDocumentedModuleMembers(ModuleMemberHighlight::All)>0 && addToIndex)
3827 {
3828 Doxygen::indexList->decContentsDepth();
3829 }
3830}
static void writeModuleMemberIndexFiltered(OutputList &ol, ModuleMemberHighlight::Enum hl)
Definition index.cpp:3681

References ModuleMemberHighlight::All, ModuleMemberHighlight::Enums, ModuleMemberHighlight::EnumValues, LayoutNavEntry::find(), ModuleMemberHighlight::Functions, Doxygen::indexList, Index::instance(), LayoutDocManager::instance(), LayoutDocManager::rootNavEntry(), theTranslator, LayoutNavEntry::title(), ModuleMemberHighlight::Typedefs, ModuleMemberHighlight::Variables, LayoutNavEntry::visible(), and writeModuleMemberIndexFiltered().

Referenced by writeIndexHierarchyEntries().

◆ writeModuleMemberIndexFiltered()

void writeModuleMemberIndexFiltered ( OutputList & ol,
ModuleMemberHighlight::Enum hl )
static

Definition at line 3681 of file index.cpp.

3683{
3684 const auto &index = Index::instance();
3685 if (index.numDocumentedModuleMembers(hl)==0) return;
3686
3687 bool disableIndex = Config_getBool(DISABLE_INDEX);
3688 bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
3689 bool fullSidebar = Config_getBool(FULL_SIDEBAR);
3690 bool dynamicMenus = Config_getBool(HTML_DYNAMIC_MENUS);
3691 bool quickLinksAfterSplitbar = !disableIndex && generateTreeView && fullSidebar;
3692
3693 bool multiPageIndex=FALSE;
3694 if (index.numDocumentedModuleMembers(hl)>MAX_ITEMS_BEFORE_MULTIPAGE_INDEX)
3695 {
3696 multiPageIndex=TRUE;
3697 }
3698
3699 ol.pushGeneratorState();
3701
3703 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ModuleMembers);
3704 QCString title = lne ? lne->title() : theTranslator->trModulesMembers();
3705 bool addToIndex = lne==nullptr || lne->visible();
3706
3707 if (addToIndex)
3708 {
3709 Doxygen::indexList->addContentsItem(multiPageIndex,getMmhlInfo(hl)->title,QCString(),
3710 getMmhlInfo(hl)->fname,QCString(),multiPageIndex,TRUE);
3711 if (multiPageIndex) Doxygen::indexList->incContentsDepth();
3712 }
3713
3714 bool first=TRUE;
3715 for (const auto &[letter,list] : index.isModuleIndexLetterUsed(hl))
3716 {
3717 QCString fileName = getMmhlInfo(hl)->fname;
3718 if (multiPageIndex)
3719 {
3720 QCString cs(letter);
3721 if (!first)
3722 {
3723 fileName+="_"+letterToLabel(cs);
3724 }
3725 if (addToIndex)
3726 {
3727 Doxygen::indexList->addContentsItem(FALSE,cs,QCString(),fileName,QCString(),FALSE,TRUE);
3728 }
3729 }
3730
3731 bool quickIndex = index.numDocumentedModuleMembers(hl)>maxItemsBeforeQuickIndex;
3732
3733 auto writeQuickLinks = [&,cap_letter=letter]()
3734 {
3736 if (!dynamicMenus)
3737 {
3739
3740 // index item for all namespace member lists
3743 ol.writeString(fixSpaces(getMmhlInfo(0)->title));
3745
3746 // index items per category member lists
3747 for (int i=1;i<ModuleMemberHighlight::Total;i++)
3748 {
3749 if (index.numDocumentedModuleMembers(static_cast<ModuleMemberHighlight::Enum>(i))>0)
3750 {
3752 getMmhlInfo(i)->fname+Doxygen::htmlFileExtension,hl==i,TRUE,first);
3753 ol.writeString(fixSpaces(getMmhlInfo(i)->title));
3755 }
3756 }
3757
3759
3760 if (quickIndex)
3761 {
3762 writeQuickMemberIndex(ol,index.isModuleIndexLetterUsed(hl),cap_letter,
3763 getMmhlInfo(hl)->fname,multiPageIndex);
3764 }
3765
3766 ol.writeString("</div><!-- main-nav -->\n");
3767 }
3768 };
3769
3770 ol.startFile(fileName+extension,QCString(),title);
3771 ol.startQuickIndices();
3772 if (!disableIndex && !quickLinksAfterSplitbar)
3773 {
3774 writeQuickLinks();
3775 }
3776 ol.endQuickIndices();
3777 ol.writeSplitBar(fileName,QCString());
3778 if (quickLinksAfterSplitbar)
3779 {
3780 writeQuickLinks();
3781 if (!dynamicMenus)
3782 {
3783 ol.writeString("<div id=\"container\">\n");
3784 ol.writeString("<div id=\"doc-content\">\n");
3785 }
3786 }
3787 ol.writeSearchInfo();
3788
3789 ol.startContents();
3790
3791 ol.startTextBlock();
3792 ol.parseText(hl == ModuleMemberHighlight::All && lne ? lne->intro() : theTranslator->trModuleMembersDescriptionTotal(hl));
3793 ol.endTextBlock();
3794
3795 writeMemberList(ol,quickIndex,
3796 multiPageIndex ? letter : std::string(),
3797 index.isModuleIndexLetterUsed(hl),
3799 endFile(ol);
3800 first=FALSE;
3801 }
3802 if (multiPageIndex && addToIndex) Doxygen::indexList->decContentsDepth();
3803 ol.popGeneratorState();
3804}
const char * fname
Definition index.cpp:3661

References ModuleMemberHighlight::All, Config_getBool, OutputList::disableAllBut(), endFile(), endQuickIndexItem(), endQuickIndexList(), OutputList::endQuickIndices(), OutputList::endTextBlock(), FALSE, LayoutNavEntry::find(), fixSpaces(), MmhlInfo::fname, getMmhlInfo(), Html, Doxygen::htmlFileExtension, Doxygen::indexList, Index::instance(), LayoutDocManager::instance(), LayoutNavEntry::intro(), letterToLabel(), MAX_ITEMS_BEFORE_MULTIPAGE_INDEX, maxItemsBeforeQuickIndex, ModuleMembers, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), OutputList::startFile(), startQuickIndexItem(), startQuickIndexList(), OutputList::startQuickIndices(), OutputList::startTextBlock(), theTranslator, LayoutNavEntry::title(), ModuleMemberHighlight::Total, TRUE, Definition::TypeModule, LayoutNavEntry::visible(), writeMemberList(), OutputList::writeQuickLinks(), writeQuickMemberIndex(), OutputList::writeSearchInfo(), OutputList::writeSplitBar(), and OutputList::writeString().

Referenced by writeModuleMemberIndex().

◆ writeModuleMembers()

void writeModuleMembers ( const ModuleDef * mod,
bool addToIndex )
static

Definition at line 1815 of file index.cpp.

1816{
1817 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Module))
1818 {
1819 if (lde->kind()==LayoutDocEntry::MemberDecl)
1820 {
1821 const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
1822 if (lmd)
1823 {
1824 MemberList *ml = mod->getMemberList(lmd->type);
1825 if (ml)
1826 {
1827 for (const auto &md : *ml)
1828 {
1829 //printf(" member %s visible=%d\n",qPrint(md->name()),md->visibleInIndex());
1830 if (md->visibleInIndex())
1831 {
1832 writeMemberToIndex(mod,md,addToIndex);
1833 }
1834 }
1835 }
1836 }
1837 }
1838 }
1839}
virtual MemberList * getMemberList(MemberListType lt) const =0
Represents of a member declaration list with configurable title and subtitle.
Definition layout.h:112
MemberListType type
Definition layout.h:118

References ModuleDef::getMemberList(), LayoutDocManager::instance(), LayoutDocEntryMemberDecl::type, and writeMemberToIndex().

Referenced by writeModuleTreeNode().

◆ writeModuleTreeNode()

void writeModuleTreeNode ( OutputList & ol,
const ModuleDef * mod,
FTVHelp * ftv,
bool addToIndex )
static

Definition at line 4448 of file index.cpp.

4450{
4451 int visibleMembers = mod->countVisibleMembers();
4452 bool isDir=visibleMembers>0;
4453 if (addToIndex)
4454 {
4455 Doxygen::indexList->addContentsItem(isDir,mod->name(),
4456 mod->getReference(),mod->getOutputFileBase(),QCString(),isDir,TRUE);
4457 }
4458 if (ftv)
4459 {
4460 ftv->addContentsItem(false,mod->name(),
4461 mod->getReference(),mod->getOutputFileBase(),QCString(),
4462 false,false,mod);
4463 }
4464 ol.startIndexListItem();
4466 ol.parseText(mod->qualifiedName());
4468 if (mod->isReference())
4469 {
4470 ol.startTypewriter();
4471 ol.docify(" [external]");
4472 ol.endTypewriter();
4473 }
4474 if (addToIndex && isDir)
4475 {
4476 Doxygen::indexList->incContentsDepth();
4477 }
4478 if (isDir)
4479 {
4480 //ftv->incContentsDepth();
4481 writeClassTree(mod->getClasses(),nullptr,addToIndex,FALSE,ClassDef::Class);
4482 writeConceptList(mod->getConcepts(),nullptr,addToIndex);
4483 writeModuleMembers(mod,addToIndex);
4484 //ftv->decContentsDepth();
4485 }
4486 if (addToIndex && isDir)
4487 {
4488 Doxygen::indexList->decContentsDepth();
4489 }
4490 ol.endIndexListItem();
4491}
virtual int countVisibleMembers() const =0
virtual const ConceptLinkedRefMap & getConcepts() const =0
virtual const ClassLinkedRefMap & getClasses() const =0
static void writeModuleMembers(const ModuleDef *mod, bool addToIndex)
Definition index.cpp:1815

References FTVHelp::addContentsItem(), ClassDef::Class, ModuleDef::countVisibleMembers(), OutputList::docify(), OutputList::endIndexItem(), OutputList::endIndexListItem(), OutputList::endTypewriter(), FALSE, ModuleDef::getClasses(), ModuleDef::getConcepts(), Definition::getOutputFileBase(), Definition::getReference(), Doxygen::indexList, Definition::isReference(), Definition::name(), OutputList::parseText(), Definition::qualifiedName(), OutputList::startIndexItem(), OutputList::startIndexListItem(), OutputList::startTypewriter(), TRUE, writeClassTree(), writeConceptList(), and writeModuleMembers().

Referenced by writeModuleList().

◆ writeNamespaceIndex()

void writeNamespaceIndex ( OutputList & ol)
static

Definition at line 2023 of file index.cpp.

2024{
2025 if (Index::instance().numDocumentedNamespaces()==0) return;
2026 ol.pushGeneratorState();
2029 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::NamespaceList);
2030 if (lne==nullptr) lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Namespaces); // fall back
2031 QCString title = lne ? lne->title() : theTranslator->trNamespaceList();
2032 bool addToIndex = lne==nullptr || lne->visible();
2033 startFile(ol,"namespaces",QCString(),title,HighlightedItem::Namespaces);
2034 startTitle(ol,QCString());
2035 ol.parseText(title);
2036 endTitle(ol,QCString(),QCString());
2037 ol.startContents();
2038 ol.startTextBlock();
2039 ol.parseText(lne ? lne->intro() : theTranslator->trNamespaceListDescription(Config_getBool(EXTRACT_ALL)));
2040 ol.endTextBlock();
2041
2042 bool first=TRUE;
2043
2044 // ---------------
2045 // Linear namespace index for Latex/RTF
2046 // ---------------
2047 ol.pushGeneratorState();
2049
2050 for (const auto &nd : *Doxygen::namespaceLinkedMap)
2051 {
2052 if (nd->isLinkableInProject())
2053 {
2054 if (first)
2055 {
2056 ol.startIndexList();
2057 first=FALSE;
2058 }
2059 //ol.writeStartAnnoItem("namespace",nd->getOutputFileBase(),0,nd->name());
2060 ol.startIndexKey();
2061 if (nd->getLanguage()==SrcLangExt::VHDL)
2062 {
2063 ol.writeObjectLink(QCString(), nd->getOutputFileBase().replace(0,qstrlen("namespace"),"class"),QCString(),nd->displayName());
2064 }
2065 else
2066 {
2067 ol.writeObjectLink(QCString(),nd->getOutputFileBase(),QCString(),nd->displayName());
2068 }
2069 ol.endIndexKey();
2070
2071 bool hasBrief = !nd->briefDescription().isEmpty();
2072 ol.startIndexValue(hasBrief);
2073 if (hasBrief)
2074 {
2075 //ol.docify(" (");
2076 ol.generateDoc(
2077 nd->briefFile(),nd->briefLine(),
2078 nd.get(),nullptr,
2079 nd->briefDescription(TRUE),
2080 FALSE, // index words
2081 FALSE, // isExample
2082 QCString(), // example name
2083 TRUE, // single line
2084 TRUE // link from index
2085 );
2086 //ol.docify(")");
2087 }
2088 ol.endIndexValue(nd->getOutputFileBase(),hasBrief);
2089
2090 }
2091 }
2092 if (!first) ol.endIndexList();
2093
2094 ol.popGeneratorState();
2095
2096 // ---------------
2097 // Hierarchical namespace index for HTML
2098 // ---------------
2099 ol.pushGeneratorState();
2101
2102 {
2103 if (addToIndex)
2104 {
2105 Doxygen::indexList->addContentsItem(TRUE,title,QCString(),"namespaces",QCString(),TRUE,TRUE);
2106 Doxygen::indexList->incContentsDepth();
2107 }
2108 FTVHelp ftv(false);
2110 TextStream t;
2111 ftv.generateTreeViewInline(t);
2112 ol.writeString(t.str().c_str());
2113 if (addToIndex)
2114 {
2115 Doxygen::indexList->decContentsDepth();
2116 }
2117 }
2118
2119 ol.popGeneratorState();
2120 // ------
2121
2122 endFile(ol);
2123 ol.popGeneratorState();
2124}
static void writeNamespaceTree(const NamespaceLinkedRefMap &nsLinkedMap, FTVHelp *ftv, bool rootOnly, bool addToIndex)
Definition index.cpp:1906

References Config_getBool, OutputList::disable(), OutputList::disableAllBut(), Docbook, endFile(), OutputList::endIndexKey(), OutputList::endIndexList(), OutputList::endIndexValue(), OutputList::endTextBlock(), endTitle(), FALSE, LayoutNavEntry::find(), OutputList::generateDoc(), FTVHelp::generateTreeViewInline(), Html, Doxygen::indexList, Index::instance(), LayoutDocManager::instance(), LayoutNavEntry::intro(), Man, Doxygen::namespaceLinkedMap, Namespaces, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), qstrlen(), QCString::replace(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), startFile(), OutputList::startIndexKey(), OutputList::startIndexList(), OutputList::startIndexValue(), OutputList::startTextBlock(), startTitle(), TextStream::str(), theTranslator, LayoutNavEntry::title(), TRUE, LayoutNavEntry::visible(), writeNamespaceTree(), OutputList::writeObjectLink(), and OutputList::writeString().

Referenced by writeIndexHierarchyEntries().

◆ writeNamespaceLinkForMember()

void writeNamespaceLinkForMember ( OutputList & ol,
const MemberDef * md,
const QCString & separator,
QCString & prevNamespaceName )
static

Definition at line 2733 of file index.cpp.

2735{
2736 const NamespaceDef *nd=md->getNamespaceDef();
2737 if (nd && prevNamespaceName!=nd->displayName())
2738 {
2739 ol.writeString(separator);
2741 nd->displayName());
2742 prevNamespaceName = nd->displayName();
2743 }
2744}

References Definition::anchor(), Definition::displayName(), MemberDef::getNamespaceDef(), Definition::getOutputFileBase(), Definition::getReference(), OutputList::writeObjectLink(), and OutputList::writeString().

Referenced by writeMemberList().

◆ writeNamespaceMemberIndex()

void writeNamespaceMemberIndex ( OutputList & ol)
static

Definition at line 3629 of file index.cpp.

3630{
3631 const auto &index = Index::instance();
3632 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::NamespaceMembers);
3633 bool addToIndex = lne==nullptr || lne->visible();
3634 if (index.numDocumentedNamespaceMembers(NamespaceMemberHighlight::All)>0 && addToIndex)
3635 {
3636 Doxygen::indexList->addContentsItem(true,lne ? lne->title() : theTranslator->trNamespaceMembers(),QCString(),"namespacemembers",QCString());
3637 Doxygen::indexList->incContentsDepth();
3638 }
3639 //bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
3648 if (index.numDocumentedNamespaceMembers(NamespaceMemberHighlight::All)>0 && addToIndex)
3649 {
3650 Doxygen::indexList->decContentsDepth();
3651 }
3652
3653}
static void writeNamespaceMemberIndexFiltered(OutputList &ol, NamespaceMemberHighlight::Enum hl)
Definition index.cpp:3504

References NamespaceMemberHighlight::All, NamespaceMemberHighlight::Dictionaries, NamespaceMemberHighlight::Enums, NamespaceMemberHighlight::EnumValues, LayoutNavEntry::find(), NamespaceMemberHighlight::Functions, Doxygen::indexList, Index::instance(), LayoutDocManager::instance(), LayoutDocManager::rootNavEntry(), NamespaceMemberHighlight::Sequences, theTranslator, LayoutNavEntry::title(), NamespaceMemberHighlight::Typedefs, NamespaceMemberHighlight::Variables, LayoutNavEntry::visible(), and writeNamespaceMemberIndexFiltered().

Referenced by writeIndexHierarchyEntries().

◆ writeNamespaceMemberIndexFiltered()

void writeNamespaceMemberIndexFiltered ( OutputList & ol,
NamespaceMemberHighlight::Enum hl )
static

Definition at line 3504 of file index.cpp.

3506{
3507 const auto &index = Index::instance();
3508 if (index.numDocumentedNamespaceMembers(hl)==0) return;
3509
3510 bool disableIndex = Config_getBool(DISABLE_INDEX);
3511 bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
3512 bool fullSidebar = Config_getBool(FULL_SIDEBAR);
3513 bool dynamicMenus = Config_getBool(HTML_DYNAMIC_MENUS);
3514 bool quickLinksAfterSplitbar = !disableIndex && generateTreeView && fullSidebar;
3515
3516 bool multiPageIndex=FALSE;
3517 if (index.numDocumentedNamespaceMembers(hl)>MAX_ITEMS_BEFORE_MULTIPAGE_INDEX)
3518 {
3519 multiPageIndex=TRUE;
3520 }
3521
3522 ol.pushGeneratorState();
3524
3526 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::NamespaceMembers);
3527 QCString title = lne ? lne->title() : theTranslator->trNamespaceMembers();
3528 bool addToIndex = lne==nullptr || lne->visible();
3529
3530 if (addToIndex)
3531 {
3532 Doxygen::indexList->addContentsItem(multiPageIndex,getNmhlInfo(hl)->title,QCString(),
3533 getNmhlInfo(hl)->fname,QCString(),multiPageIndex,TRUE);
3534 if (multiPageIndex) Doxygen::indexList->incContentsDepth();
3535 }
3536
3537 bool first=TRUE;
3538 for (const auto &[letter,list] : index.isNamespaceIndexLetterUsed(hl))
3539 {
3540 QCString fileName = getNmhlInfo(hl)->fname;
3541 if (multiPageIndex)
3542 {
3543 QCString cs(letter);
3544 if (!first)
3545 {
3546 fileName+="_"+letterToLabel(cs);
3547 }
3548 if (addToIndex)
3549 {
3550 Doxygen::indexList->addContentsItem(FALSE,cs,QCString(),fileName,QCString(),FALSE,TRUE);
3551 }
3552 }
3553
3554 bool quickIndex = index.numDocumentedNamespaceMembers(hl)>maxItemsBeforeQuickIndex;
3555
3556 auto writeQuickLinks = [&,cap_letter=letter]()
3557 {
3559 if (!dynamicMenus)
3560 {
3562
3563 // index item for all namespace member lists
3566 ol.writeString(fixSpaces(getNmhlInfo(0)->title));
3568
3569 // index items per category member lists
3570 for (int i=1;i<NamespaceMemberHighlight::Total;i++)
3571 {
3572 if (index.numDocumentedNamespaceMembers(static_cast<NamespaceMemberHighlight::Enum>(i))>0)
3573 {
3575 getNmhlInfo(i)->fname+Doxygen::htmlFileExtension,hl==i,TRUE,first);
3576 ol.writeString(fixSpaces(getNmhlInfo(i)->title));
3578 }
3579 }
3580
3582
3583 if (quickIndex)
3584 {
3585 writeQuickMemberIndex(ol,index.isNamespaceIndexLetterUsed(hl),cap_letter,
3586 getNmhlInfo(hl)->fname,multiPageIndex);
3587 }
3588
3589 ol.writeString("</div><!-- main-nav -->\n");
3590 }
3591 };
3592
3593 ol.startFile(fileName+extension,QCString(),title);
3594 ol.startQuickIndices();
3595 if (!disableIndex && !quickLinksAfterSplitbar)
3596 {
3597 writeQuickLinks();
3598 }
3599 ol.endQuickIndices();
3600 ol.writeSplitBar(fileName,QCString());
3601 if (quickLinksAfterSplitbar)
3602 {
3603 writeQuickLinks();
3604 if (!dynamicMenus)
3605 {
3606 ol.writeString("<div id=\"container\">\n");
3607 ol.writeString("<div id=\"doc-content\">\n");
3608 }
3609 }
3610 ol.writeSearchInfo();
3611
3612 ol.startContents();
3613
3614 ol.startTextBlock();
3615 ol.parseText(hl == NamespaceMemberHighlight::All && lne ? lne->intro() : theTranslator->trNamespaceMembersDescriptionTotal(hl));
3616 ol.endTextBlock();
3617
3618 writeMemberList(ol,quickIndex,
3619 multiPageIndex ? letter : std::string(),
3620 index.isNamespaceIndexLetterUsed(hl),
3622 endFile(ol);
3623 first=FALSE;
3624 }
3625 if (multiPageIndex && addToIndex) Doxygen::indexList->decContentsDepth();
3626 ol.popGeneratorState();
3627}
@ NamespaceMembers
Definition index.h:78
const char * fname
Definition index.cpp:3476

References NamespaceMemberHighlight::All, Config_getBool, OutputList::disableAllBut(), endFile(), endQuickIndexItem(), endQuickIndexList(), OutputList::endQuickIndices(), OutputList::endTextBlock(), FALSE, LayoutNavEntry::find(), fixSpaces(), NmhlInfo::fname, getNmhlInfo(), Html, Doxygen::htmlFileExtension, Doxygen::indexList, Index::instance(), LayoutDocManager::instance(), LayoutNavEntry::intro(), letterToLabel(), MAX_ITEMS_BEFORE_MULTIPAGE_INDEX, maxItemsBeforeQuickIndex, NamespaceMembers, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), OutputList::startFile(), startQuickIndexItem(), startQuickIndexList(), OutputList::startQuickIndices(), OutputList::startTextBlock(), theTranslator, LayoutNavEntry::title(), NamespaceMemberHighlight::Total, TRUE, Definition::TypeNamespace, LayoutNavEntry::visible(), writeMemberList(), OutputList::writeQuickLinks(), writeQuickMemberIndex(), OutputList::writeSearchInfo(), OutputList::writeSplitBar(), and OutputList::writeString().

Referenced by writeNamespaceMemberIndex().

◆ writeNamespaceMembers()

void writeNamespaceMembers ( const NamespaceDef * nd,
bool addToIndex )
static

Definition at line 1789 of file index.cpp.

1790{
1791 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Namespace))
1792 {
1793 if (lde->kind()==LayoutDocEntry::MemberDef)
1794 {
1795 const LayoutDocEntryMemberDef *lmd = dynamic_cast<const LayoutDocEntryMemberDef*>(lde.get());
1796 if (lmd)
1797 {
1798 MemberList *ml = nd->getMemberList(lmd->type);
1799 if (ml)
1800 {
1801 for (const auto &md : *ml)
1802 {
1803 //printf(" member %s visible=%d\n",qPrint(md->name()),md->visibleInIndex());
1804 if (md->visibleInIndex())
1805 {
1806 writeMemberToIndex(nd,md,addToIndex);
1807 }
1808 }
1809 }
1810 }
1811 }
1812 }
1813}
virtual MemberList * getMemberList(MemberListType lt) const =0

References NamespaceDef::getMemberList(), LayoutDocManager::instance(), LayoutDocEntryMemberDef::type, and writeMemberToIndex().

Referenced by writeNamespaceTreeElement().

◆ writeNamespaceTree() [1/2]

void writeNamespaceTree ( const NamespaceLinkedMap & nsLinkedMap,
FTVHelp * ftv,
bool rootOnly,
bool addToIndex )
static

Definition at line 1918 of file index.cpp.

1920{
1921 for (const auto &nd : nsLinkedMap)
1922 {
1923 if (nd->isVisibleInHierarchy())
1924 {
1925 writeNamespaceTreeElement(nd.get(),ftv,rootOnly,addToIndex);
1926 }
1927 }
1928}
static void writeNamespaceTreeElement(const NamespaceDef *nd, FTVHelp *ftv, bool rootOnly, bool addToIndex)
Definition index.cpp:1846

References writeNamespaceTreeElement().

◆ writeNamespaceTree() [2/2]

void writeNamespaceTree ( const NamespaceLinkedRefMap & nsLinkedMap,
FTVHelp * ftv,
bool rootOnly,
bool addToIndex )
static

Definition at line 1906 of file index.cpp.

1908{
1909 for (const auto &nd : nsLinkedMap)
1910 {
1911 if (nd->isVisibleInHierarchy())
1912 {
1913 writeNamespaceTreeElement(nd,ftv,rootOnly,addToIndex);
1914 }
1915 }
1916}

References writeNamespaceTreeElement().

Referenced by writeNamespaceIndex(), and writeNamespaceTreeElement().

◆ writeNamespaceTreeElement()

void writeNamespaceTreeElement ( const NamespaceDef * nd,
FTVHelp * ftv,
bool rootOnly,
bool addToIndex )
static

Definition at line 1846 of file index.cpp.

1848{
1849 if (!nd->isAnonymous() &&
1850 (!rootOnly || nd->getOuterScope()==Doxygen::globalScope))
1851 {
1852
1853 bool hasNestedNamespace = namespaceHasNestedNamespace(nd);
1854 bool hasChildren = hasNestedNamespace ||
1857 bool isLinkable = nd->isLinkable();
1858 int visibleMembers = nd->countVisibleMembers();
1859
1860 //printf("namespace %s hasChildren=%d visibleMembers=%d\n",qPrint(nd->name()),hasChildren,visibleMembers);
1861
1862 QCString ref;
1863 QCString file;
1864 if (isLinkable)
1865 {
1866 ref = nd->getReference();
1867 file = nd->getOutputFileBase();
1868 if (nd->getLanguage()==SrcLangExt::VHDL) // UGLY HACK
1869 {
1870 file=file.replace(0,qstrlen("namespace"),"class");
1871 }
1872 }
1873
1874 bool isDir = hasChildren || visibleMembers>0;
1875 if (isLinkable || isDir)
1876 {
1877 ftv->addContentsItem(hasNestedNamespace,nd->localName(),ref,file,QCString(),FALSE,nd->partOfGroups().empty(),nd);
1878
1879 if (addToIndex)
1880 {
1881 Doxygen::indexList->addContentsItem(isDir,nd->localName(),ref,file,QCString(),
1882 hasChildren && !file.isEmpty(),nd->partOfGroups().empty());
1883 }
1884 if (addToIndex && isDir)
1885 {
1886 Doxygen::indexList->incContentsDepth();
1887 }
1888
1889 if (isDir)
1890 {
1891 ftv->incContentsDepth();
1892 writeNamespaceTree(nd->getNamespaces(),ftv,FALSE,addToIndex);
1893 writeClassTree(nd->getClasses(),nullptr,addToIndex,FALSE,ClassDef::Class);
1894 writeConceptList(nd->getConcepts(),nullptr,addToIndex);
1895 writeNamespaceMembers(nd,addToIndex);
1896 ftv->decContentsDepth();
1897 }
1898 if (addToIndex && isDir)
1899 {
1900 Doxygen::indexList->decContentsDepth();
1901 }
1902 }
1903 }
1904}
virtual int countVisibleMembers() const =0
static void writeNamespaceMembers(const NamespaceDef *nd, bool addToIndex)
Definition index.cpp:1789
bool namespaceHasNestedNamespace(const NamespaceDef *nd)

References FTVHelp::addContentsItem(), ClassDef::Class, NamespaceDef::countVisibleMembers(), FTVHelp::decContentsDepth(), FALSE, NamespaceDef::getClasses(), NamespaceDef::getConcepts(), Definition::getLanguage(), NamespaceDef::getNamespaces(), Definition::getOuterScope(), Definition::getOutputFileBase(), Definition::getReference(), Doxygen::globalScope, FTVHelp::incContentsDepth(), Doxygen::indexList, Definition::isAnonymous(), QCString::isEmpty(), Definition::isLinkable(), Definition::localName(), namespaceHasNestedClass(), namespaceHasNestedConcept(), namespaceHasNestedNamespace(), Definition::partOfGroups(), qstrlen(), QCString::replace(), writeClassTree(), writeConceptList(), writeNamespaceMembers(), and writeNamespaceTree().

Referenced by writeNamespaceTree(), and writeNamespaceTree().

◆ writePageIndex()

void writePageIndex ( OutputList & ol)
static

Definition at line 3989 of file index.cpp.

3990{
3991 if (Index::instance().numIndexedPages()==0) return;
3992 ol.pushGeneratorState();
3994 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Pages);
3995 QCString title = lne ? lne->title() : theTranslator->trRelatedPages();
3996 startFile(ol,"pages",QCString(),title,HighlightedItem::Pages);
3997 startTitle(ol,QCString());
3998 ol.parseText(title);
3999 endTitle(ol,QCString(),QCString());
4000 ol.startContents();
4001 ol.startTextBlock();
4002 ol.parseText(lne ? lne->intro() : theTranslator->trRelatedPagesDescription());
4003 ol.endTextBlock();
4004
4005 {
4006 FTVHelp ftv(false);
4007 for (const auto &pd : *Doxygen::pageLinkedMap)
4008 {
4009 if ((pd->getOuterScope()==nullptr ||
4010 pd->getOuterScope()->definitionType()!=Definition::TypePage) && // not a sub page
4011 pd->visibleInIndex()
4012 )
4013 {
4014 writePages(pd.get(),&ftv);
4015 }
4016 }
4017 TextStream t;
4018 ftv.generateTreeViewInline(t);
4019 ol.writeString(t.str().c_str());
4020 }
4021
4022// ol.popGeneratorState();
4023 // ------
4024
4025 endFile(ol);
4026 ol.popGeneratorState();
4027}

References OutputList::disableAllBut(), endFile(), OutputList::endTextBlock(), endTitle(), LayoutNavEntry::find(), FTVHelp::generateTreeViewInline(), Html, Index::instance(), LayoutDocManager::instance(), LayoutNavEntry::intro(), Doxygen::pageLinkedMap, Pages, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), startFile(), OutputList::startTextBlock(), startTitle(), TextStream::str(), theTranslator, LayoutNavEntry::title(), Definition::TypePage, writePages(), and OutputList::writeString().

Referenced by writeIndexHierarchyEntries().

◆ writePages()

void writePages ( PageDef * pd,
FTVHelp * ftv )
static

Definition at line 3928 of file index.cpp.

3929{
3930 //printf("writePages()=%s pd=%p mainpage=%p\n",qPrint(pd->name()),(void*)pd,(void*)Doxygen::mainPage.get());
3931 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Pages);
3932 bool addToIndex = lne==nullptr || lne->visible();
3933 if (!addToIndex) return;
3934
3935 bool hasSubPages = pd->hasSubPages();
3936 bool hasSections = pd->hasSections();
3937
3938 if (pd->visibleInIndex())
3939 {
3940 QCString pageTitle, pageTitleAsHtml;
3941
3942 if (pd->title().isEmpty())
3943 pageTitle=pd->name();
3944 else
3945 pageTitle = parseCommentAsText(pd,nullptr,pd->title(),pd->getDefFileName(),pd->getDefLine());
3946 pageTitleAsHtml = parseCommentAsHtml(pd,nullptr,pd->title(),pd->getDefFileName(),pd->getDefLine());
3947
3948 if (ftv)
3949 {
3950 //printf("*** adding %s hasSubPages=%d hasSections=%d\n",qPrint(pageTitle),hasSubPages,hasSections);
3951 ftv->addContentsItem(
3952 hasSubPages,pageTitle,
3953 pd->getReference(),pd->getOutputFileBase(),
3954 QCString(),hasSubPages,TRUE,pd,pageTitleAsHtml);
3955 }
3956 if (addToIndex && pd!=Doxygen::mainPage.get())
3957 {
3958 Doxygen::indexList->addContentsItem(
3959 hasSubPages || hasSections,pageTitle,
3960 pd->getReference(),pd->getOutputFileBase(),
3961 QCString(),hasSubPages,TRUE,pd,pageTitleAsHtml);
3962 }
3963 }
3964 if (hasSubPages && ftv) ftv->incContentsDepth();
3965 bool doIndent = (hasSections || hasSubPages) &&
3966 (pd!=Doxygen::mainPage.get() || mainPageHasOwnTitle());
3967 if (doIndent)
3968 {
3969 Doxygen::indexList->incContentsDepth();
3970 }
3971 if (hasSections)
3972 {
3973 pd->addSectionsToIndex();
3974 }
3975 for (const auto &subPage : pd->getSubPages())
3976 {
3977 writePages(subPage,ftv);
3978 }
3979 if (hasSubPages && ftv) ftv->decContentsDepth();
3980 if (doIndent)
3981 {
3982 Doxygen::indexList->decContentsDepth();
3983 }
3984 //printf("end writePages()=%s\n",qPrint(pd->title()));
3985}
virtual bool hasSections() const =0
virtual void addSectionsToIndex()=0
virtual bool visibleInIndex() const =0
virtual const PageLinkedRefMap & getSubPages() const =0
virtual bool hasSubPages() const =0
virtual QCString title() const =0
static bool mainPageHasOwnTitle()
Definition index.cpp:3917

References FTVHelp::addContentsItem(), PageDef::addSectionsToIndex(), FTVHelp::decContentsDepth(), LayoutNavEntry::find(), Definition::getDefFileName(), Definition::getDefLine(), Definition::getOutputFileBase(), Definition::getReference(), PageDef::getSubPages(), Definition::hasSections(), PageDef::hasSubPages(), FTVHelp::incContentsDepth(), Doxygen::indexList, LayoutDocManager::instance(), QCString::isEmpty(), Doxygen::mainPage, mainPageHasOwnTitle(), Definition::name(), parseCommentAsHtml(), parseCommentAsText(), LayoutDocManager::rootNavEntry(), PageDef::title(), TRUE, LayoutNavEntry::visible(), PageDef::visibleInIndex(), and writePages().

Referenced by writeGroupTreeNode(), writeIndex(), writePageIndex(), and writePages().

◆ writeQuickMemberIndex()

void writeQuickMemberIndex ( OutputList & ol,
const Index::MemberIndexMap & map,
const std::string & page,
QCString fullName,
bool multiPage )
static

Definition at line 3074 of file index.cpp.

3077{
3078 bool first=TRUE;
3080 for (const auto &[letter,list] : map)
3081 {
3082 QCString ci(letter);
3083 QCString is = letterToLabel(ci);
3084 QCString anchor;
3086 if (!multiPage)
3087 anchor="#index_";
3088 else if (first)
3089 anchor=fullName+extension+"#index_";
3090 else
3091 anchor=fullName+"_"+is+extension+"#index_";
3092 startQuickIndexItem(ol,anchor+convertToId(is),letter==page,TRUE,first);
3093 ol.writeString(ci);
3095 first=FALSE;
3096 }
3098}

References convertToId(), endQuickIndexItem(), endQuickIndexList(), FALSE, Doxygen::htmlFileExtension, letterToLabel(), startQuickIndexItem(), startQuickIndexList(), TRUE, and OutputList::writeString().

Referenced by writeClassMemberIndexFiltered(), writeFileMemberIndexFiltered(), writeModuleMemberIndexFiltered(), and writeNamespaceMemberIndexFiltered().

◆ writeSingleFileIndex()

void writeSingleFileIndex ( OutputList & ol,
const FileDef * fd )
static

Definition at line 1463 of file index.cpp.

1464{
1465 //printf("Found filedef %s\n",qPrint(fd->name()));
1466 bool doc = fd->isLinkableInProject();
1467 bool src = fd->generateSourceFile();
1468 bool nameOk = !fd->isDocumentationFile();
1469 if (nameOk && (doc || src) && !fd->isReference())
1470 {
1471 QCString path;
1472 if (Config_getBool(FULL_PATH_NAMES))
1473 {
1474 path=stripFromPath(fd->getPath());
1475 }
1476 QCString fullName=fd->name();
1477 if (!path.isEmpty())
1478 {
1479 if (path.at(path.length()-1)!='/') fullName.prepend("/");
1480 fullName.prepend(path);
1481 }
1482
1483 ol.startIndexKey();
1484 ol.docify(path);
1485 if (doc)
1486 {
1488 //if (addToIndex)
1489 //{
1490 // addMembersToIndex(fd,LayoutDocManager::File,fullName,QCString());
1491 //}
1492 }
1493 else if (src)
1494 {
1496 }
1497 if (doc && src)
1498 {
1499 ol.pushGeneratorState();
1501 ol.docify(" ");
1503 ol.docify("[");
1504 ol.parseText(theTranslator->trCode());
1505 ol.docify("]");
1506 ol.endTextLink();
1507 ol.popGeneratorState();
1508 }
1509 ol.endIndexKey();
1510 bool hasBrief = !fd->briefDescription().isEmpty();
1511 ol.startIndexValue(hasBrief);
1512 if (hasBrief)
1513 {
1514 //ol.docify(" (");
1515 ol.generateDoc(
1516 fd->briefFile(),fd->briefLine(),
1517 fd,nullptr,
1519 FALSE, // index words
1520 FALSE, // isExample
1521 QCString(), // example name
1522 TRUE, // single line
1523 TRUE // link from index
1524 );
1525 //ol.docify(")");
1526 }
1527 if (doc)
1528 {
1529 ol.endIndexValue(fd->getOutputFileBase(),hasBrief);
1530 }
1531 else // src
1532 {
1533 ol.endIndexValue(fd->getSourceFileBase(),hasBrief);
1534 }
1535 //ol.popGeneratorState();
1536 // --------------------------------------------------------
1537 }
1538}
virtual int briefLine() const =0
virtual QCString briefDescription(bool abbreviate=FALSE) const =0
virtual QCString getSourceFileBase() const =0
virtual QCString briefFile() const =0
virtual QCString includeName() const =0
virtual QCString getPath() const =0
virtual bool generateSourceFile() const =0
virtual bool isDocumentationFile() const =0
size_t length() const
Returns the length of the string, not counting the 0-terminator.
Definition qcstring.h:153
static QCString stripFromPath(const QCString &p, const StringVector &l)
Definition util.cpp:310

References QCString::at(), Definition::briefDescription(), Definition::briefFile(), Definition::briefLine(), Config_getBool, OutputList::disableAllBut(), OutputList::docify(), OutputList::endIndexKey(), OutputList::endIndexValue(), OutputList::endTextLink(), FALSE, OutputList::generateDoc(), FileDef::generateSourceFile(), Definition::getOutputFileBase(), FileDef::getPath(), Definition::getSourceFileBase(), Html, FileDef::includeName(), FileDef::isDocumentationFile(), QCString::isEmpty(), Definition::isLinkableInProject(), Definition::isReference(), QCString::length(), Definition::name(), OutputList::parseText(), OutputList::popGeneratorState(), QCString::prepend(), OutputList::pushGeneratorState(), OutputList::startIndexKey(), OutputList::startIndexValue(), OutputList::startTextLink(), stripFromPath(), theTranslator, TRUE, and OutputList::writeObjectLink().

Referenced by writeFileIndex().

◆ writeTopicIndex()

void writeTopicIndex ( OutputList & ol)
static

Definition at line 4379 of file index.cpp.

4380{
4381 if (Index::instance().numDocumentedGroups()==0) return;
4382 ol.pushGeneratorState();
4383 // 1.{
4386 LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Topics);
4387 QCString title = lne ? lne->title() : theTranslator->trTopics();
4388 bool addToIndex = lne==nullptr || lne->visible();
4389
4390 startFile(ol,"topics",QCString(),title,HighlightedItem::Topics);
4391 startTitle(ol,QCString());
4392 ol.parseText(title);
4393 endTitle(ol,QCString(),QCString());
4394 ol.startContents();
4395 ol.startTextBlock();
4396 ol.parseText(lne ? lne->intro() : theTranslator->trTopicListDescription());
4397 ol.endTextBlock();
4398
4399 // ---------------
4400 // Normal group index for Latex/RTF
4401 // ---------------
4402 // 2.{
4403 ol.pushGeneratorState();
4405 Doxygen::indexList->disable();
4406
4407 writeGroupHierarchy(ol,nullptr,FALSE);
4408
4409 Doxygen::indexList->enable();
4410 ol.popGeneratorState();
4411 // 2.}
4412
4413 // ---------------
4414 // interactive group index for HTML
4415 // ---------------
4416 // 2.{
4417 ol.pushGeneratorState();
4419
4420 {
4421 if (addToIndex)
4422 {
4423 Doxygen::indexList->addContentsItem(TRUE,title,QCString(),"topics",QCString(),TRUE,TRUE);
4424 Doxygen::indexList->incContentsDepth();
4425 }
4426 FTVHelp ftv(false);
4427 writeGroupHierarchy(ol,&ftv,addToIndex);
4428 TextStream t;
4429 ftv.generateTreeViewInline(t);
4431 ol.writeString(t.str().c_str());
4432 if (addToIndex)
4433 {
4434 Doxygen::indexList->decContentsDepth();
4435 }
4436 }
4437 ol.popGeneratorState();
4438 // 2.}
4439
4440 endFile(ol);
4441 ol.popGeneratorState();
4442 // 1.}
4443}
static void writeGroupHierarchy(OutputList &ol, FTVHelp *ftv, bool addToIndex)
Definition index.cpp:4355

References OutputList::disable(), OutputList::disableAllBut(), Docbook, endFile(), OutputList::endTextBlock(), endTitle(), FALSE, LayoutNavEntry::find(), FTVHelp::generateTreeViewInline(), Html, Doxygen::indexList, Index::instance(), LayoutDocManager::instance(), LayoutNavEntry::intro(), Man, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), startFile(), OutputList::startTextBlock(), startTitle(), TextStream::str(), theTranslator, LayoutNavEntry::title(), Topics, TRUE, LayoutNavEntry::visible(), writeGroupHierarchy(), and OutputList::writeString().

Referenced by writeIndexHierarchyEntries().

◆ writeUserGroupStubPage()

void writeUserGroupStubPage ( OutputList & ol,
LayoutNavEntry * lne )
static

Definition at line 4798 of file index.cpp.

4799{
4800 if (lne->baseFile().startsWith("usergroup"))
4801 {
4802 ol.pushGeneratorState();
4805 startTitle(ol,QCString());
4806 ol.parseText(lne->title());
4807 endTitle(ol,QCString(),QCString());
4808 ol.startContents();
4809 int count=0;
4810 for (const auto &entry: lne->children())
4811 {
4812 if (entry->visible()) count++;
4813 }
4814 if (count>0)
4815 {
4816 ol.writeString("<ul>\n");
4817 for (const auto &entry: lne->children())
4818 {
4819 if (entry->visible())
4820 {
4821 ol.writeString("<li><a href=\""+entry->url()+"\"><span>"+
4822 fixSpaces(entry->title())+"</span></a></li>\n");
4823 }
4824 }
4825 ol.writeString("</ul>\n");
4826 }
4827 endFile(ol);
4828 ol.popGeneratorState();
4829 }
4830}
bool startsWith(const char *s) const
Definition qcstring.h:492
QCString baseFile() const
Definition layout.h:214

References LayoutNavEntry::baseFile(), LayoutNavEntry::children(), OutputList::disableAllBut(), endFile(), endTitle(), fixSpaces(), Html, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), OutputList::startContents(), startFile(), QCString::startsWith(), startTitle(), LayoutNavEntry::title(), UserGroup, and OutputList::writeString().

Referenced by writeIndexHierarchyEntries().

Variable Documentation

◆ indexWritten

std::vector<bool> indexWritten
static

Definition at line 5234 of file index.cpp.

Referenced by writeIndexHierarchyEntries().

◆ maxItemsBeforeQuickIndex