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)

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

void	endFileWithNavPath (OutputList &ol, const Definition *d)

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	writeFileIndex (OutputList &ol)

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

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

template<>
const ClassDef *	get_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 CmhlInfo *	getCmhlInfo (size_t hl)

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

static void	writeClassMemberIndex (OutputList &ol)

static const FmhlInfo *	getFmhlInfo (size_t hl)

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

static void	writeFileMemberIndex (OutputList &ol)

static const NmhlInfo *	getNmhlInfo (size_t hl)

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

static void	writeNamespaceMemberIndex (OutputList &ol)

static const MmhlInfo *	getMmhlInfo (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

#define MAX_ITEMS_BEFORE_MULTIPAGE_INDEX 200

Definition at line 55 of file index.cpp.

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

◆ 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 2247 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 523 of file index.cpp.

{
  int numClasses=0;
  for (const auto &cd : def->getClasses())
  {
    if (cd->isLinkable()) numClasses++;
  }
  int numConcepts=0;
  if (concepts)
  {
    for (const auto &cd : *concepts)
    {
      if (cd->isLinkable()) numConcepts++;
    }
  }
  bool hasMembers = !def->getMemberLists().empty() || !def->getMemberGroups().empty() || (numClasses>0) || (numConcepts>0);
  Doxygen::indexList->addContentsItem(hasMembers,name,
                                     def->getReference(),def->getOutputFileBase(),anchor,
                                     hasMembers && !preventSeparateIndex,
                                     addToIndex,
                                     def);
  //printf("addMembersToIndex(def=%s hasMembers=%d numClasses=%d)\n",qPrint(def->name()),hasMembers,numClasses);
  if (hasMembers || numClasses>0 || numConcepts>0)
  {
    Doxygen::indexList->incContentsDepth();
    for (const auto &lde : LayoutDocManager::instance().docEntries(part))
    {
      auto kind = lde->kind();
      if (kind==LayoutDocEntry::MemberDef)
      {
        const LayoutDocEntryMemberDef *lmd = dynamic_cast<const LayoutDocEntryMemberDef*>(lde.get());
        if (lmd)
        {
          MemberList *ml = def->getMemberList(lmd->type);
          if (ml)
          {
            for (const auto &md : *ml)
            {
              if (md->visibleInIndex())
              {
                writeMemberToIndex(def,md,addToIndex);
              }
            }
          }
        }
      }
      else if (kind==LayoutDocEntry::NamespaceClasses ||
               kind==LayoutDocEntry::FileClasses ||
               kind==LayoutDocEntry::ClassNestedClasses ||
               kind==LayoutDocEntry::ModuleClasses
              )
      {
        for (const auto &cd : def->getClasses())
        {
          if (cd->isLinkable() && (cd->partOfGroups().empty() || def->definitionType()==Definition::TypeGroup))
          {
            bool inlineSimpleStructs = Config_getBool(INLINE_SIMPLE_STRUCTS);
            bool isNestedClass = def->definitionType()==Definition::TypeClass;
            addMembersToIndex(cd,LayoutDocManager::Class,cd->displayName(lde->kind()==LayoutDocEntry::FileClasses),cd->anchor(),
                              addToIndex && (isNestedClass || (cd->isSimple() && inlineSimpleStructs)),
                              preventSeparateIndex || cd->isEmbeddedInOuterScope());
          }
        }
      }
      else if ((kind==LayoutDocEntry::FileConcepts || kind==LayoutDocEntry::ModuleConcepts) && concepts)
      {
        for (const auto &cd : *concepts)
        {
          if (cd->isLinkable() && (cd->partOfGroups().empty() || def->definitionType()==Definition::TypeGroup))
          {
            Doxygen::indexList->addContentsItem(false,cd->displayName(),
                                     cd->getReference(),cd->getOutputFileBase(),QCString(),
                                     addToIndex,
                                     false,
                                     cd);
          }
        }
      }
    }
 
    Doxygen::indexList->decContentsDepth();
  }
}

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

◆ countAnnotatedClasses()

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

static

Definition at line 2097 of file index.cpp.

{
  bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
  int count=0;
  int countPrinted=0;
  for (const auto &cd : *Doxygen::classLinkedMap)
  {
    if (sliceOpt && cd->compoundType() != ct)
    {
      continue;
    }
    if (cd->isLinkableInProject() && !cd->isImplicitTemplateInstance())
    {
      if (!cd->isEmbeddedInOuterScope())
      {
        countPrinted++;
      }
      count++;
    }
  }
  *cp = countPrinted;
  return count;
}

References Doxygen::classLinkedMap, and Config_getBool.

Referenced by Index::countDataStructures().

◆ countClassesInTreeList()

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

static

Definition at line 1085 of file index.cpp.

{
  bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
  int count=0;
  for (const auto &cd : cl)
  {
    if (sliceOpt && cd->compoundType() != ct)
    {
      continue;
    }
    if (!classHasVisibleRoot(cd->baseClasses())) // filter on root classes
    {
      if (cd->isVisibleInHierarchy()) // should it be visible
      {
        if (!cd->subClasses().empty()) // should have sub classes
        {
          count++;
        }
      }
    }
  }
  return count;
}

References classHasVisibleRoot(), and Config_getBool.

Referenced by countClassHierarchy().

◆ countClassHierarchy()

static int countClassHierarchy ( ClassDef::CompoundType ct )

static

Definition at line 1109 of file index.cpp.

{
  int count=0;
  count+=countClassesInTreeList(*Doxygen::classLinkedMap, ct);
  count+=countClassesInTreeList(*Doxygen::hiddenClassLinkedMap, ct);
  return count;
}

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

Referenced by Index::countDataStructures().

◆ countConcepts()

static int countConcepts ( )

static

Definition at line 1677 of file index.cpp.

{
  int count=0;
  for (const auto &cd : *Doxygen::conceptLinkedMap)
  {
    if (cd->isLinkableInProject()) count++;
  }
  return count;
}

References Doxygen::conceptLinkedMap.

Referenced by Index::countDataStructures().

◆ countDirs()

static int countDirs ( )

static

Definition at line 3984 of file index.cpp.

{
  int count=0;
  for (const auto &dd : *Doxygen::dirLinkedMap)
  {
    if (dd->isLinkableInProject())
    {
      count++;
    }
  }
  return count;
}

References Doxygen::dirLinkedMap.

Referenced by Index::countDataStructures().

◆ countFiles()

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

static

Definition at line 1436 of file index.cpp.

{
  allFiles=0;
  docFiles=0;
  for (const auto &fn : *Doxygen::inputNameLinkedMap)
  {
    for (const auto &fd: *fn)
    {
      bool src = false;
      bool doc = fileVisibleInIndex(fd.get(),src);
      if (doc || src)
      {
        allFiles++;
      }
      if (doc)
      {
        docFiles++;
      }
    }
  }
}

References fileVisibleInIndex(), and Doxygen::inputNameLinkedMap.

Referenced by Index::countDataStructures().

◆ countGroups()

static int countGroups ( )

static

Definition at line 3968 of file index.cpp.

{
  int count=0;
  for (const auto &gd : *Doxygen::groupLinkedMap)
  {
    if (!gd->isReference())
    {
      //gd->visited=FALSE;
      count++;
    }
  }
  return count;
}

References Doxygen::groupLinkedMap.

Referenced by Index::countDataStructures().

◆ countNamespaces()

static int countNamespaces ( )

static

Definition at line 1666 of file index.cpp.

{
  int count=0;
  for (const auto &nd : *Doxygen::namespaceLinkedMap)
  {
    if (nd->isLinkableInProject()) count++;
  }
  return count;
}

References Doxygen::namespaceLinkedMap.

Referenced by Index::countDataStructures().

◆ countRelatedPages()

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

static

Definition at line 3837 of file index.cpp.

{
  docPages=indexPages=0;
  for (const auto &pd : *Doxygen::pageLinkedMap)
  {
    if (pd->visibleInIndex() && !pd->hasParentPage())
    {
      indexPages++;
    }
    if (pd->documentedPage())
    {
      docPages++;
    }
  }
}

References Doxygen::pageLinkedMap.

Referenced by Index::countDataStructures().

◆ dirHasVisibleChildren()

static bool dirHasVisibleChildren ( const DirDef * dd )

static

Definition at line 723 of file index.cpp.

{
  if (dd->hasDocumentation()) return TRUE;
 
  for (const auto &fd : dd->getFiles())
  {
    bool genSourceFile = false;
    if (fileVisibleInIndex(fd,genSourceFile))
    {
      return TRUE;
    }
    if (genSourceFile)
    {
      return TRUE;
    }
  }
 
  for(const auto &subdd : dd->subDirs())
  {
    if (dirHasVisibleChildren(subdd))
    {
      return TRUE;
    }
  }
  return FALSE;
}

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 426 of file index.cpp.

{
  bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
  ol.pushGeneratorState();
  ol.disableAllBut(OutputType::Html);
  if (!skipNavIndex)
  {
    if (!skipEndContents) ol.endContents();
    if (generateTreeView)
    {
      ol.writeString("</div><!-- doc-content -->\n");
    }
  }
 
  ol.writeFooter(navPath); // write the footer
  ol.popGeneratorState();
  ol.endFile();
}

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(), 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 Definition *	d )

Definition at line 446 of file index.cpp.

{
  bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
  QCString navPath;
  if (generateTreeView)
  {
    ol.pushGeneratorState();
    ol.disableAllBut(OutputType::Html);
    ol.writeString("</div><!-- doc-content -->\n");
    ol.popGeneratorState();
    navPath = d->navigationPathAsString();
  }
  endFile(ol,generateTreeView,TRUE,navPath);
}

References Config_getBool, OutputList::disableAllBut(), endFile(), Html, Definition::navigationPathAsString(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), TRUE, 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()

static void endIndexHierarchy	(	OutputList &	ol,
		int	level )

static

Definition at line 323 of file index.cpp.

{
  ol.pushGeneratorState();
  ol.disable(OutputType::Man);
  ol.disable(OutputType::Html);
  if (level<6) ol.endIndexList();
  ol.popGeneratorState();
 
  ol.pushGeneratorState();
  ol.disable(OutputType::Latex);
  ol.disable(OutputType::Docbook);
  ol.disable(OutputType::RTF);
  ol.endItemList();
  ol.popGeneratorState();
}

References OutputList::disable(), Docbook, OutputList::endIndexList(), OutputList::endItemList(), Html, Latex, Man, OutputList::popGeneratorState(), OutputList::pushGeneratorState(), and RTF.

Referenced by writeClassHierarchy(), writeClassTreeToOutput(), writeDirHierarchy(), writeDirTreeNode(), writeGroupHierarchy(), writeGroupTreeNode(), and writeModuleList().

◆ endQuickIndexItem()

static void endQuickIndexItem ( OutputList & ol )

static

Definition at line 377 of file index.cpp.

{
  ol.writeString("</span>");
  ol.writeString("</a>");
  ol.writeString("</li>\n");
}

References OutputList::writeString().

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

◆ endQuickIndexList()

static void endQuickIndexList ( OutputList & ol )

static

Definition at line 358 of file index.cpp.

{
  ol.writeString("    </ul>\n");
  ol.writeString("  </div>\n");
}

References OutputList::writeString().

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

◆ endTitle()

void endTitle	(	OutputList &	ol,
		const QCString &	fileName,
		const QCString &	name )

Definition at line 393 of file index.cpp.

{
  ol.popGeneratorState();
  ol.endTitleHead(fileName,name);
  ol.endHeaderSection();
}

References OutputList::endHeaderSection(), OutputList::endTitleHead(), and OutputList::popGeneratorState().

Referenced by generateExampleDocs(), writeAlphabeticalExceptionIndex(), writeAlphabeticalIndex(), writeAlphabeticalInterfaceIndex(), writeAlphabeticalStructIndex(), writeAnnotatedIndexGeneric(), writeConceptIndex(), 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().

◆ get_pointer() [1/3]

template<>

const ClassDef * get_pointer ( const ClassLinkedMap::Ptr & p )

Definition at line 1690 of file index.cpp.

1690{ return p.get(); }

◆ get_pointer() [2/3]

template<>

const ClassDef * get_pointer ( const ClassLinkedRefMap::Ptr & p )

Definition at line 1691 of file index.cpp.

1691{ return p; }

◆ get_pointer() [3/3]

template<typename Ptr>

const ClassDef * get_pointer ( const Ptr & p )

Referenced by writeClassTree().

◆ getCmhlInfo()

static const CmhlInfo * getCmhlInfo ( size_t hl )

static

Definition at line 3080 of file index.cpp.

{
  bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
  bool vhdlOpt    = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
  static CmhlInfo cmhlInfo[] =
  {
    CmhlInfo("functions",     theTranslator->trAll()),
    CmhlInfo("functions_func",
        fortranOpt ? theTranslator->trSubprograms()     :
        vhdlOpt    ? theTranslator->trFunctionAndProc() :
                     theTranslator->trFunctions()),
    CmhlInfo("functions_vars",theTranslator->trVariables()),
    CmhlInfo("functions_type",theTranslator->trTypedefs()),
    CmhlInfo("functions_enum",theTranslator->trEnumerations()),
    CmhlInfo("functions_eval",theTranslator->trEnumerationValues()),
    CmhlInfo("functions_prop",theTranslator->trProperties()),
    CmhlInfo("functions_evnt",theTranslator->trEvents()),
    CmhlInfo("functions_rela",theTranslator->trRelatedSymbols())
  };
  return &cmhlInfo[hl];
}

References Config_getBool, and theTranslator.

Referenced by renderQuickLinksAsJs(), and writeClassMemberIndexFiltered().

◆ getFmhlInfo()

static const FmhlInfo * getFmhlInfo ( size_t hl )

static

Definition at line 3260 of file index.cpp.

{
  bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
  bool vhdlOpt    = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
  bool sliceOpt   = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
  static FmhlInfo fmhlInfo[] =
  {
    FmhlInfo("globals",     theTranslator->trAll()),
    FmhlInfo("globals_func",
         fortranOpt ? theTranslator->trSubprograms()     :
         vhdlOpt    ? theTranslator->trFunctionAndProc() :
                      theTranslator->trFunctions()),
    FmhlInfo("globals_vars",sliceOpt ? theTranslator->trConstants() : theTranslator->trVariables()),
    FmhlInfo("globals_type",theTranslator->trTypedefs()),
    FmhlInfo("globals_sequ",theTranslator->trSequences()),
    FmhlInfo("globals_dict",theTranslator->trDictionaries()),
    FmhlInfo("globals_enum",theTranslator->trEnumerations()),
    FmhlInfo("globals_eval",theTranslator->trEnumerationValues()),
    FmhlInfo("globals_defs",theTranslator->trDefines())
  };
  return &fmhlInfo[hl];
}

References Config_getBool, and theTranslator.

Referenced by renderQuickLinksAsJs(), and writeFileMemberIndexFiltered().

◆ getMmhlInfo()

static const MmhlInfo * getMmhlInfo ( size_t hl )

static

Definition at line 3611 of file index.cpp.

{
  static MmhlInfo nmhlInfo[] =
  {
    MmhlInfo("modulemembers",     theTranslator->trAll()),
    MmhlInfo("modulemembers_func",theTranslator->trFunctions()),
    MmhlInfo("modulemembers_vars",theTranslator->trVariables()),
    MmhlInfo("modulemembers_type",theTranslator->trTypedefs()),
    MmhlInfo("modulemembers_enum",theTranslator->trEnumerations()),
    MmhlInfo("modulemembers_eval",theTranslator->trEnumerationValues())
  };
  return &nmhlInfo[hl];
}

References theTranslator.

Referenced by renderQuickLinksAsJs(), and writeModuleMemberIndexFiltered().

◆ getNmhlInfo()

static const NmhlInfo * getNmhlInfo ( size_t hl )

static

Definition at line 3434 of file index.cpp.

{
  bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
  bool vhdlOpt    = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
  bool sliceOpt   = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
  static NmhlInfo nmhlInfo[] =
  {
    NmhlInfo("namespacemembers",     theTranslator->trAll()),
    NmhlInfo("namespacemembers_func",
        fortranOpt ? theTranslator->trSubprograms()     :
        vhdlOpt    ? theTranslator->trFunctionAndProc() :
                     theTranslator->trFunctions()),
    NmhlInfo("namespacemembers_vars",sliceOpt ? theTranslator->trConstants() : theTranslator->trVariables()),
    NmhlInfo("namespacemembers_type",theTranslator->trTypedefs()),
    NmhlInfo("namespacemembers_sequ",theTranslator->trSequences()),
    NmhlInfo("namespacemembers_dict",theTranslator->trDictionaries()),
    NmhlInfo("namespacemembers_enum",theTranslator->trEnumerations()),
    NmhlInfo("namespacemembers_eval",theTranslator->trEnumerationValues())
  };
  return &nmhlInfo[hl];
}

References Config_getBool, and theTranslator.

Referenced by renderQuickLinksAsJs(), and writeNamespaceMemberIndexFiltered().

◆ isId1()

bool isId1 ( int c )

inline

Definition at line 2196 of file index.cpp.

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

Referenced by letterToLabel().

◆ letterToLabel()

static QCString letterToLabel ( const QCString & startLetter )

static

Definition at line 2201 of file index.cpp.

{
  if (startLetter.isEmpty()) return startLetter;
  const char *p = startLetter.data();
  char c = *p;
  QCString result;
  if (isId1(c))
  {
    result+=c;
  }
  else
  {
    result="0x";
    const char hex[]="0123456789abcdef";
    while ((c=*p++))
    {
      result+=hex[static_cast<unsigned char>(c)>>4];
      result+=hex[static_cast<unsigned char>(c)&0xf];
    }
  }
  return result;
}

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

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

◆ mainPageHasOwnTitle()

static bool mainPageHasOwnTitle ( )

static

Definition at line 3855 of file index.cpp.

{
  QCString projectName = Config_getString(PROJECT_NAME);
  QCString title;
  if (Doxygen::mainPage)
  {
    title = filterTitle(Doxygen::mainPage->title());
  }
  return !projectName.isEmpty() && mainPageHasTitle() && qstricmp(title,projectName)!=0;
}

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

Referenced by writePages().

◆ MemberIndexMap_add()

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

static

Definition at line 180 of file index.cpp.

{
  auto it = map.find(letter);
  if (it!=map.end())
  {
    it->second.push_back(md);
  }
  else
  {
    map.emplace(letter,std::vector<const MemberDef*>({md}));
  }
}

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

◆ quickLinkVisible()

static bool quickLinkVisible ( LayoutNavEntry::Kind kind )

static

Definition at line 5449 of file index.cpp.

{
  const auto &index = Index::instance();
  bool showNamespaces = Config_getBool(SHOW_NAMESPACES);
  bool showFiles = Config_getBool(SHOW_FILES);
  bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
  switch (kind)
  {
    case LayoutNavEntry::MainPage:           return TRUE;
    case LayoutNavEntry::User:               return TRUE;
    case LayoutNavEntry::UserGroup:          return TRUE;
    case LayoutNavEntry::Pages:              return index.numIndexedPages()>0;
    case LayoutNavEntry::Topics:             return index.numDocumentedGroups()>0;
    case LayoutNavEntry::Modules:            return index.numDocumentedModules()>0;
    case LayoutNavEntry::ModuleList:         return index.numDocumentedModules()>0;
    case LayoutNavEntry::ModuleMembers:      return index.numDocumentedModuleMembers(ModuleMemberHighlight::All)>0;
    case LayoutNavEntry::Namespaces:         return index.numDocumentedNamespaces()>0 && showNamespaces;
    case LayoutNavEntry::NamespaceList:      return index.numDocumentedNamespaces()>0 && showNamespaces;
    case LayoutNavEntry::NamespaceMembers:   return index.numDocumentedNamespaceMembers(NamespaceMemberHighlight::All)>0;
    case LayoutNavEntry::Concepts:           return index.numDocumentedConcepts()>0;
    case LayoutNavEntry::Classes:            return index.numAnnotatedClasses()>0;
    case LayoutNavEntry::ClassList:          return index.numAnnotatedClasses()>0;
    case LayoutNavEntry::ClassIndex:         return index.numAnnotatedClasses()>0;
    case LayoutNavEntry::ClassHierarchy:     return index.numHierarchyClasses()>0;
    case LayoutNavEntry::ClassMembers:       return index.numDocumentedClassMembers(ClassMemberHighlight::All)>0 && !sliceOpt;
    case LayoutNavEntry::Interfaces:         return index.numAnnotatedInterfaces()>0;
    case LayoutNavEntry::InterfaceList:      return index.numAnnotatedInterfaces()>0;
    case LayoutNavEntry::InterfaceIndex:     return index.numAnnotatedInterfaces()>0;
    case LayoutNavEntry::InterfaceHierarchy: return index.numHierarchyInterfaces()>0;
    case LayoutNavEntry::Structs:            return index.numAnnotatedStructs()>0;
    case LayoutNavEntry::StructList:         return index.numAnnotatedStructs()>0;
    case LayoutNavEntry::StructIndex:        return index.numAnnotatedStructs()>0;
    case LayoutNavEntry::Exceptions:         return index.numAnnotatedExceptions()>0;
    case LayoutNavEntry::ExceptionList:      return index.numAnnotatedExceptions()>0;
    case LayoutNavEntry::ExceptionIndex:     return index.numAnnotatedExceptions()>0;
    case LayoutNavEntry::ExceptionHierarchy: return index.numHierarchyExceptions()>0;
    case LayoutNavEntry::Files:              return index.numDocumentedFiles()>0 && showFiles;
    case LayoutNavEntry::FileList:           return index.numDocumentedFiles()>0 && showFiles;
    case LayoutNavEntry::FileGlobals:        return index.numDocumentedFileMembers(FileMemberHighlight::All)>0;
    case LayoutNavEntry::Examples:           return !Doxygen::exampleLinkedMap->empty();
    case LayoutNavEntry::None:             // should never happen, means not properly initialized
      assert(kind != LayoutNavEntry::None);
      return FALSE;
  }
  return FALSE;
}

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 5497 of file index.cpp.

{
  // index items per category member lists
  bool firstMember=TRUE;
  for (std::size_t i=0;i<total;i++)
  {
    if (numDocumented(i)>0)
    {
      t << ",";
      if (firstMember)
      {
        t << "children:[";
        firstMember=FALSE;
      }
      t << "\n{text:\"" << convertToJSString(getInfo(i)->title) << "\",url:\""
        << convertToJSString(getInfo(i)->fname+Doxygen::htmlFileExtension) << "\"";
 
      // Check if we have many members, then add sub entries per letter...
      // quick alphabetical index
      bool quickIndex = numDocumented(i)>maxItemsBeforeQuickIndex;
      if (quickIndex)
      {
        bool multiPageIndex=FALSE;
        if (numDocumented(i)>MAX_ITEMS_BEFORE_MULTIPAGE_INDEX)
        {
          multiPageIndex=TRUE;
        }
        t << ",children:[\n";
        bool firstLetter=TRUE;
        for (const auto &[letter,list] : getMemberList(i))
        {
          if (!firstLetter) t << ",\n";
          QCString ci(letter);
          QCString is(letterToLabel(ci));
          QCString anchor;
          QCString extension=Doxygen::htmlFileExtension;
          QCString fullName = getInfo(i)->fname;
          if (!multiPageIndex || firstLetter)
            anchor=fullName+extension+"#index_";
          else // other pages of multi page index
            anchor=fullName+"_"+is+extension+"#index_";
          t << "{text:\"" << convertToJSString(ci) << "\",url:\""
            << convertToJSString(anchor+convertToId(is)) << "\"}";
          firstLetter=FALSE;
        }
        t << "]";
      }
      t << "}";
    }
  }
  if (!firstMember)
  {
    t << "]";
  }
}

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

Referenced by renderQuickLinksAsJs().

◆ renderQuickLinksAsJs()

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

static

Definition at line 5557 of file index.cpp.

{
  int count=0;
  for (const auto &entry : root->children())
  {
    if (entry->visible() && quickLinkVisible(entry->kind())) count++;
  }
  if (count>0) // at least one item is visible
  {
    bool firstChild = TRUE;
    if (!first) t << ",";
    t << "children:[\n";
    for (const auto &entry : root->children())
    {
      if (entry->visible() && quickLinkVisible(entry->kind()))
      {
        if (!firstChild) t << ",\n";
        firstChild=FALSE;
        QCString url = entry->url();
        if (isURL(url)) url = "^" + url;
        t << "{text:\"" << convertToJSString(entry->title()) << "\",url:\""
          << convertToJSString(url) << "\"";
        bool hasChildren=FALSE;
        if (entry->kind()==LayoutNavEntry::ModuleMembers)
        {
          auto numDoc = [](std::size_t i) {
            return Index::instance().numDocumentedModuleMembers(static_cast<ModuleMemberHighlight::Enum>(i));
          };
          auto memList = [](std::size_t i) {
            return Index::instance().isModuleIndexLetterUsed(static_cast<ModuleMemberHighlight::Enum>(i));
          };
          renderMemberIndicesAsJs(t,numDoc,memList,getMmhlInfo,static_cast<std::size_t>(ModuleMemberHighlight::Total));
        }
        if (entry->kind()==LayoutNavEntry::NamespaceMembers)
        {
          auto numDoc = [](std::size_t i) {
            return Index::instance().numDocumentedNamespaceMembers(static_cast<NamespaceMemberHighlight::Enum>(i));
          };
          auto memList = [](std::size_t i) {
            return Index::instance().isNamespaceIndexLetterUsed(static_cast<NamespaceMemberHighlight::Enum>(i));
          };
          renderMemberIndicesAsJs(t,numDoc,memList,getNmhlInfo,static_cast<std::size_t>(NamespaceMemberHighlight::Total));
        }
        else if (entry->kind()==LayoutNavEntry::ClassMembers)
        {
          auto numDoc = [](std::size_t i) {
            return Index::instance().numDocumentedClassMembers(static_cast<ClassMemberHighlight::Enum>(i));
          };
          auto memList = [](std::size_t i) {
            return Index::instance().isClassIndexLetterUsed(static_cast<ClassMemberHighlight::Enum>(i));
          };
          renderMemberIndicesAsJs(t,numDoc,memList,getCmhlInfo,static_cast<std::size_t>(ClassMemberHighlight::Total));
        }
        else if (entry->kind()==LayoutNavEntry::FileGlobals)
        {
          auto numDoc = [](std::size_t i) {
            return Index::instance().numDocumentedFileMembers(static_cast<FileMemberHighlight::Enum>(i));
          };
          auto memList = [](std::size_t i) {
            return Index::instance().isFileIndexLetterUsed(static_cast<FileMemberHighlight::Enum>(i));
          };
          renderMemberIndicesAsJs(t,numDoc,memList,getFmhlInfo,static_cast<std::size_t>(FileMemberHighlight::Total));
        }
        else // recursive into child list
        {
          hasChildren = renderQuickLinksAsJs(t,entry.get(),FALSE);
        }
        if (hasChildren) t << "]";
        t << "}";
      }
    }
  }
  return count>0;
}

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 )

Definition at line 400 of file index.cpp.

{
  bool disableIndex     = Config_getBool(DISABLE_INDEX);
  bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
  bool fullSidebar      = Config_getBool(FULL_SIDEBAR);
  bool quickLinksAfterSplitbar = !disableIndex && generateTreeView && fullSidebar;
  ol.startFile(name,manName,title,hierarchyLevel);
  ol.startQuickIndices();
  if (!disableIndex && !quickLinksAfterSplitbar)
  {
    ol.writeQuickLinks(hli,name);
  }
  if (!additionalIndices)
  {
    ol.endQuickIndices();
  }
  ol.writeSplitBar(!altSidebarName.isEmpty() ? altSidebarName : name);
  if (quickLinksAfterSplitbar)
  {
    ol.writeQuickLinks(hli,name);
  }
  ol.writeSearchInfo();
}

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

◆ startIndexHierarchy()

static void startIndexHierarchy	(	OutputList &	ol,
		int	level )

static

Definition at line 307 of file index.cpp.

{
  ol.pushGeneratorState();
  ol.disable(OutputType::Man);
  ol.disable(OutputType::Html);
  if (level<6) ol.startIndexList();
  ol.popGeneratorState();
 
  ol.pushGeneratorState();
  ol.disable(OutputType::Latex);
  ol.disable(OutputType::RTF);
  ol.disable(OutputType::Docbook);
  ol.startItemList();
  ol.popGeneratorState();
}

References OutputList::disable(), Docbook, Html, Latex, Man, OutputList::popGeneratorState(), OutputList::pushGeneratorState(), RTF, OutputList::startIndexList(), and OutputList::startItemList().

Referenced by writeClassTreeForList(), writeClassTreeToOutput(), writeDirHierarchy(), writeDirTreeNode(), writeGroupHierarchy(), writeGroupTreeNode(), and writeModuleList().

◆ startQuickIndexItem()

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

static

Definition at line 364 of file index.cpp.

{
  first=FALSE;
  ol.writeString("      <li");
  if (hl) ol.writeString(" class=\"current\"");
  ol.writeString("><a ");
  ol.writeString("href=\"");
  ol.writeString(l);
  ol.writeString("\">");
  ol.writeString("<span>");
}

References FALSE, and OutputList::writeString().

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

◆ startQuickIndexList()

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

static

Definition at line 345 of file index.cpp.

{
  if (letterTabs)
  {
    ol.writeString("  <div id=\"navrow4\" class=\"tabs3\">\n");
  }
  else
  {
    ol.writeString("  <div id=\"navrow3\" class=\"tabs2\">\n");
  }
  ol.writeString("    <ul class=\"tablist\">\n");
}

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.

{
  ol.startHeaderSection();
  if (def) def->writeSummaryLinks(ol);
  ol.startTitleHead(fileName);
  ol.pushGeneratorState();
  ol.disable(OutputType::Man);
}

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

Referenced by generateExampleDocs(), writeAlphabeticalExceptionIndex(), writeAlphabeticalIndex(), writeAlphabeticalInterfaceIndex(), writeAlphabeticalStructIndex(), writeAnnotatedIndexGeneric(), writeConceptIndex(), 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()

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

static

Definition at line 2250 of file index.cpp.

{
  bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
 
  // What starting letters are used
  UsedIndexLetters indexLettersUsed;
 
  // first count the number of headers
  for (const auto &cd : *Doxygen::classLinkedMap)
  {
    if (sliceOpt && cd->compoundType() != ct)
      continue;
    if (cd->isLinkableInProject() && !cd->isImplicitTemplateInstance())
    {
      if (cd->getLanguage()==SrcLangExt::VHDL && !(VhdlDocGen::convert(cd->protection())==VhdlDocGen::ENTITYCLASS ))// no architecture
        continue;
 
      // get the first UTF8 character (after the part that should be ignored)
      int index = getPrefixIndex(cd->className());
      std::string letter = getUTF8CharAt(cd->className().str(),index);
      if (!letter.empty())
      {
        indexLettersUsed.insert(convertUTF8ToUpper(letter));
      }
    }
  }
 
  // write quick link index (row of letters)
  QCString alphaLinks = "<div class=\"qindex\">";
  bool first=true;
  for (const auto &letter : indexLettersUsed)
  {
    if (!first) alphaLinks += "&#160;|&#160;";
    first=false;
    QCString li = letterToLabel(letter.c_str());
    alphaLinks += "<a class=\"qindex\" href=\"#letter_" +
                  li + "\">" +
                  QCString(letter) + "</a>";
  }
  alphaLinks += "</div>\n";
  ol.writeString(alphaLinks);
 
  std::map<std::string, std::vector<const ClassDef*> > classesByLetter;
 
  // fill the columns with the class list (row elements in each column,
  // expect for the columns with number >= itemsInLastRow, which get one
  // item less.
  for (const auto &cd : *Doxygen::classLinkedMap)
  {
    if (sliceOpt && cd->compoundType() != ct)
      continue;
    if (cd->getLanguage()==SrcLangExt::VHDL && !(VhdlDocGen::convert(cd->protection())==VhdlDocGen::ENTITYCLASS ))// no architecture
      continue;
 
    if (cd->isLinkableInProject() && !cd->isImplicitTemplateInstance())
    {
      QCString className = cd->className();
      int index = getPrefixIndex(className);
      std::string letter = getUTF8CharAt(className.str(),index);
      if (!letter.empty())
      {
        letter = convertUTF8ToUpper(letter);
        auto it = classesByLetter.find(letter);
        if (it!=classesByLetter.end()) // add class to the existing list
        {
          it->second.push_back(cd.get());
        }
        else // new entry
        {
          classesByLetter.emplace(letter, std::vector<const ClassDef*>({ cd.get() }));
        }
      }
    }
  }
 
  // sort the class lists per letter while ignoring the prefix
  for (auto &[letter,list] : classesByLetter)
  {
    std::stable_sort(list.begin(), list.end(),
              [](const auto &c1,const auto &c2)
              {
                QCString n1 = c1->className();
                QCString n2 = c2->className();
                return qstricmp_sort(n1.data()+getPrefixIndex(n1), n2.data()+getPrefixIndex(n2))<0;
              });
  }
 
  // generate table
  if (!classesByLetter.empty())
  {
    ol.writeString("<div class=\"classindex\">\n");
    int counter=0;
    for (const auto &cl : classesByLetter)
    {
      QCString parity = (counter++%2)==0 ? "even" : "odd";
      ol.writeString("<dl class=\"classindex " + parity + "\">\n");
 
      // write character heading
      ol.writeString("<dt class=\"alphachar\">");
      QCString s = letterToLabel(cl.first.c_str());
      ol.writeString("<a id=\"letter_");
      ol.writeString(s);
      ol.writeString("\" name=\"letter_");
      ol.writeString(s);
      ol.writeString("\">");
      ol.writeString(cl.first.c_str());
      ol.writeString("</a>");
      ol.writeString("</dt>\n");
 
      // write class links
      for (const auto &cd : cl.second)
      {
        ol.writeString("<dd>");
        QCString namesp,cname;
        extractNamespaceName(cd->name(),cname,namesp);
        QCString nsDispName;
        SrcLangExt lang = cd->getLanguage();
        QCString sep = getLanguageSpecificSeparator(lang);
        if (sep!="::")
        {
          nsDispName=substitute(namesp,"::",sep);
          cname=substitute(cname,"::",sep);
        }
        else
        {
          nsDispName=namesp;
        }
 
        ol.writeObjectLink(cd->getReference(),
            cd->getOutputFileBase(),cd->anchor(),cname);
        if (!namesp.isEmpty())
        {
          ol.writeString(" (");
          NamespaceDef *nd = getResolvedNamespace(namesp);
          if (nd && nd->isLinkable())
          {
            ol.writeObjectLink(nd->getReference(),
                nd->getOutputFileBase(),QCString(),nsDispName);
          }
          else
          {
            ol.docify(nsDispName);
          }
          ol.writeString(")");
        }
        ol.writeString("</dd>");
      }
 
      ol.writeString("</dl>\n");
    }
    ol.writeString("</div>\n");
  }
}

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(), VHDL, OutputList::writeObjectLink(), and OutputList::writeString().

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

◆ writeAlphabeticalExceptionIndex()

static void writeAlphabeticalExceptionIndex ( OutputList & ol )

static

Definition at line 2493 of file index.cpp.

{
  if (Index::instance().numAnnotatedExceptions()==0) return;
  ol.pushGeneratorState();
  ol.disableAllBut(OutputType::Html);
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ExceptionIndex);
  QCString title = lne ? lne->title() : theTranslator->trExceptionIndex();
  bool addToIndex = lne==nullptr || lne->visible();
 
  startFile(ol,"exceptions",QCString(),title,HighlightedItem::Exceptions);
 
  startTitle(ol,QCString());
  ol.parseText(title);
  endTitle(ol,QCString(),QCString());
 
  if (addToIndex)
  {
    Doxygen::indexList->addContentsItem(FALSE,title,QCString(),"exceptions",QCString(),FALSE,TRUE);
  }
 
  ol.startContents();
  writeAlphabeticalClassList(ol, ClassDef::Exception, Index::instance().numAnnotatedExceptions());
  endFile(ol); // contains ol.endContents()
 
  ol.popGeneratorState();
}

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()

static void writeAlphabeticalIndex ( OutputList & ol )

static

Definition at line 2406 of file index.cpp.

{
  if (Index::instance().numAnnotatedClasses()==0) return;
  ol.pushGeneratorState();
  ol.disableAllBut(OutputType::Html);
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassIndex);
  QCString title = lne ? lne->title() : theTranslator->trCompoundIndex();
  bool addToIndex = lne==nullptr || lne->visible();
 
  startFile(ol,"classes",QCString(),title,HighlightedItem::Classes);
 
  startTitle(ol,QCString());
  ol.parseText(title);
  endTitle(ol,QCString(),QCString());
 
  if (addToIndex)
  {
    Doxygen::indexList->addContentsItem(FALSE,title,QCString(),"classes",QCString(),FALSE,TRUE);
  }
 
  ol.startContents();
  writeAlphabeticalClassList(ol, ClassDef::Class, Index::instance().numAnnotatedClasses());
  endFile(ol); // contains ol.endContents()
 
  ol.popGeneratorState();
}

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()

static void writeAlphabeticalInterfaceIndex ( OutputList & ol )

static

Definition at line 2435 of file index.cpp.

{
  if (Index::instance().numAnnotatedInterfaces()==0) return;
  ol.pushGeneratorState();
  ol.disableAllBut(OutputType::Html);
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::InterfaceIndex);
  QCString title = lne ? lne->title() : theTranslator->trInterfaceIndex();
  bool addToIndex = lne==nullptr || lne->visible();
 
  startFile(ol,"interfaces",QCString(),title,HighlightedItem::Interfaces);
 
  startTitle(ol,QCString());
  ol.parseText(title);
  endTitle(ol,QCString(),QCString());
 
  if (addToIndex)
  {
    Doxygen::indexList->addContentsItem(FALSE,title,QCString(),"interfaces",QCString(),FALSE,TRUE);
  }
 
  ol.startContents();
  writeAlphabeticalClassList(ol, ClassDef::Interface, Index::instance().numAnnotatedInterfaces());
  endFile(ol); // contains ol.endContents()
 
  ol.popGeneratorState();
}

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()

static void writeAlphabeticalStructIndex ( OutputList & ol )

static

Definition at line 2464 of file index.cpp.

{
  if (Index::instance().numAnnotatedStructs()==0) return;
  ol.pushGeneratorState();
  ol.disableAllBut(OutputType::Html);
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::StructIndex);
  QCString title = lne ? lne->title() : theTranslator->trStructIndex();
  bool addToIndex = lne==nullptr || lne->visible();
 
  startFile(ol,"structs",QCString(),title,HighlightedItem::Structs);
 
  startTitle(ol,QCString());
  ol.parseText(title);
  endTitle(ol,QCString(),QCString());
 
  if (addToIndex)
  {
    Doxygen::indexList->addContentsItem(FALSE,title,QCString(),"structs",QCString(),FALSE,TRUE);
  }
 
  ol.startContents();
  writeAlphabeticalClassList(ol, ClassDef::Struct, Index::instance().numAnnotatedStructs());
  endFile(ol); // contains ol.endContents()
 
  ol.popGeneratorState();
}

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()

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

static

Definition at line 2122 of file index.cpp.

{
  //LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassList);
  //bool addToIndex = lne==nullptr || lne->visible();
  bool first=TRUE;
 
  bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
 
  for (const auto &cd : *Doxygen::classLinkedMap)
  {
    if (cd->getLanguage()==SrcLangExt::VHDL &&
        (VhdlDocGen::convert(cd->protection())==VhdlDocGen::PACKAGECLASS ||
         VhdlDocGen::convert(cd->protection())==VhdlDocGen::PACKBODYCLASS)
       ) // no architecture
    {
      continue;
    }
    if (first)
    {
      ol.startIndexList();
      first=FALSE;
    }
 
    if (sliceOpt && cd->compoundType() != ct)
    {
      continue;
    }
 
    ol.pushGeneratorState();
    if (cd->isEmbeddedInOuterScope())
    {
      ol.disable(OutputType::Latex);
      ol.disable(OutputType::Docbook);
      ol.disable(OutputType::RTF);
    }
    if (cd->isLinkableInProject() && !cd->isImplicitTemplateInstance())
    {
      ol.startIndexKey();
      if (cd->getLanguage()==SrcLangExt::VHDL)
      {
        QCString prot= VhdlDocGen::getProtectionName(VhdlDocGen::convert(cd->protection()));
        ol.docify(prot);
        ol.writeString(" ");
      }
      ol.writeObjectLink(QCString(),cd->getOutputFileBase(),cd->anchor(),cd->displayName());
      ol.endIndexKey();
      bool hasBrief = !cd->briefDescription().isEmpty();
      ol.startIndexValue(hasBrief);
      if (hasBrief)
      {
        ol.generateDoc(
                 cd->briefFile(),cd->briefLine(),
                 cd.get(),nullptr,
                 cd->briefDescription(TRUE),
                 FALSE,  // indexWords
                 FALSE,  // isExample
                 QCString(),     // example name
                 TRUE,  // single line
                 TRUE,  // link from index
                 Config_getBool(MARKDOWN_SUPPORT)
                );
      }
      ol.endIndexValue(cd->getOutputFileBase(),hasBrief);
 
      //if (addToIndex)
      //{
      //  addMembersToIndex(cd,LayoutDocManager::Class,cd->displayName(),cd->anchor());
      //}
    }
    ol.popGeneratorState();
  }
  if (!first) ol.endIndexList();
}

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, VHDL, OutputList::writeObjectLink(), and OutputList::writeString().

Referenced by writeAnnotatedIndexGeneric().

◆ writeAnnotatedExceptionIndex()

static void writeAnnotatedExceptionIndex ( OutputList & ol )

static

Definition at line 2664 of file index.cpp.

{
  const auto &index = Index::instance();
  writeAnnotatedIndexGeneric(ol,
      AnnotatedIndexContext(index.numAnnotatedExceptions(),index.numAnnotatedExceptionsPrinted(),
                            LayoutNavEntry::ExceptionList,LayoutNavEntry::Exceptions,
                            theTranslator->trExceptionList(),theTranslator->trExceptionListDescription(),
                            ClassDef::Exception,
                            "annotatedexceptions",
                            HighlightedItem::AnnotatedExceptions));
}

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

Referenced by writeIndexHierarchyEntries().

◆ writeAnnotatedIndex()

static void writeAnnotatedIndex ( OutputList & ol )

static

Definition at line 2622 of file index.cpp.

{
  const auto &index = Index::instance();
  writeAnnotatedIndexGeneric(ol,
      AnnotatedIndexContext(index.numAnnotatedClasses(),index.numAnnotatedClassesPrinted(),
                            LayoutNavEntry::ClassList,LayoutNavEntry::Classes,
                            theTranslator->trCompoundList(),theTranslator->trCompoundListDescription(),
                            ClassDef::Class,
                            "annotated",
                            HighlightedItem::AnnotatedClasses));
}

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

Referenced by writeIndexHierarchyEntries().

◆ writeAnnotatedIndexGeneric()

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

static

Definition at line 2547 of file index.cpp.

{
  //printf("writeAnnotatedIndex: count=%d printed=%d\n",
  //    annotatedClasses,annotatedClassesPrinted);
  if (ctx.numAnnotated==0) return;
 
  ol.pushGeneratorState();
  ol.disable(OutputType::Man);
  if (ctx.numPrinted==0)
  {
    ol.disable(OutputType::Latex);
    ol.disable(OutputType::RTF);
  }
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(ctx.listKind);
  if (lne==nullptr) lne = LayoutDocManager::instance().rootNavEntry()->find(ctx.fallbackKind); // fall back
  QCString title = lne ? lne->title() : ctx.listDefaultTitleText;
  bool addToIndex = lne==nullptr || lne->visible();
 
  startFile(ol,ctx.fileBaseName,QCString(),title,ctx.hiItem);
 
  startTitle(ol,QCString());
  ol.parseText(title);
  endTitle(ol,QCString(),QCString());
 
  ol.startContents();
 
  ol.startTextBlock();
  ol.parseText(lne ? lne->intro() : ctx.listDefaultIntroText);
  ol.endTextBlock();
 
  // ---------------
  // Linear class index for Latex/RTF
  // ---------------
  ol.pushGeneratorState();
  ol.disable(OutputType::Html);
  Doxygen::indexList->disable();
 
  writeAnnotatedClassList(ol, ctx.compoundType);
 
  Doxygen::indexList->enable();
  ol.popGeneratorState();
 
  // ---------------
  // Hierarchical class index for HTML
  // ---------------
  ol.pushGeneratorState();
  ol.disableAllBut(OutputType::Html);
 
  {
    if (addToIndex)
    {
      Doxygen::indexList->addContentsItem(TRUE,title,QCString(),ctx.fileBaseName,QCString(),TRUE,TRUE);
      Doxygen::indexList->incContentsDepth();
    }
    FTVHelp ftv(false);
    writeClassTreeInsideNamespace(*Doxygen::namespaceLinkedMap,&ftv,TRUE,addToIndex,ctx.compoundType);
    writeClassTree(*Doxygen::classLinkedMap,&ftv,addToIndex,TRUE,ctx.compoundType);
    TextStream t;
    ftv.generateTreeViewInline(t);
    ol.writeString(t.str().c_str());
    if (addToIndex)
    {
      Doxygen::indexList->decContentsDepth();
    }
  }
 
  ol.popGeneratorState();
  // ------
 
  endFile(ol); // contains ol.endContents()
  ol.popGeneratorState();
}

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

◆ writeAnnotatedInterfaceIndex()

static void writeAnnotatedInterfaceIndex ( OutputList & ol )

static

Definition at line 2636 of file index.cpp.

{
  const auto &index = Index::instance();
  writeAnnotatedIndexGeneric(ol,
      AnnotatedIndexContext(index.numAnnotatedInterfaces(),index.numAnnotatedInterfacesPrinted(),
                            LayoutNavEntry::InterfaceList,LayoutNavEntry::Interfaces,
                            theTranslator->trInterfaceList(),theTranslator->trInterfaceListDescription(),
                            ClassDef::Interface,
                            "annotatedinterfaces",
                            HighlightedItem::AnnotatedInterfaces));
}

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

Referenced by writeIndexHierarchyEntries().

◆ writeAnnotatedStructIndex()

static void writeAnnotatedStructIndex ( OutputList & ol )

static

Definition at line 2650 of file index.cpp.

{
  const auto &index = Index::instance();
  writeAnnotatedIndexGeneric(ol,
      AnnotatedIndexContext(index.numAnnotatedStructs(),index.numAnnotatedStructsPrinted(),
                            LayoutNavEntry::StructList,LayoutNavEntry::Structs,
                            theTranslator->trStructList(),theTranslator->trStructListDescription(),
                            ClassDef::Struct,
                            "annotatedstructs",
                            HighlightedItem::AnnotatedStructs));
}

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

Referenced by writeIndexHierarchyEntries().

◆ writeClassHierarchy()

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

static

Definition at line 1058 of file index.cpp.

{
  ClassDefSet visitedClasses;
  if (ftv)
  {
    ol.pushGeneratorState();
    ol.disable(OutputType::Html);
  }
  bool started=FALSE;
  writeClassTreeForList(ol,*Doxygen::classLinkedMap,started,ftv,addToIndex,ct,visitedClasses);
  writeClassTreeForList(ol,*Doxygen::hiddenClassLinkedMap,started,ftv,addToIndex,ct,visitedClasses);
  if (started)
  {
    endIndexHierarchy(ol,0);
    if (addToIndex)
    {
      Doxygen::indexList->decContentsDepth();
    }
  }
  if (ftv)
  {
    ol.popGeneratorState();
  }
}

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()

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

static

Definition at line 2677 of file index.cpp.

{
  const ClassDef *cd=md->getClassDef();
  if ( cd && prevClassName!=cd->displayName())
  {
    ol.writeString(separator);
    ol.writeObjectLink(md->getReference(),md->getOutputFileBase(),md->anchor(),
        cd->displayName());
    prevClassName = cd->displayName();
  }
}

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

Referenced by writeMemberList().

◆ writeClassMemberIndex()

static void writeClassMemberIndex ( OutputList & ol )

static

Definition at line 3223 of file index.cpp.

{
  const auto &index = Index::instance();
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassMembers);
  bool addToIndex = lne==nullptr || lne->visible();
 
  if (index.numDocumentedClassMembers(ClassMemberHighlight::All)>0 && addToIndex)
  {
    Doxygen::indexList->addContentsItem(TRUE,lne ? lne->title() : theTranslator->trCompoundMembers(),QCString(),"functions",QCString());
    Doxygen::indexList->incContentsDepth();
  }
  writeClassMemberIndexFiltered(ol,ClassMemberHighlight::All);
  writeClassMemberIndexFiltered(ol,ClassMemberHighlight::Functions);
  writeClassMemberIndexFiltered(ol,ClassMemberHighlight::Variables);
  writeClassMemberIndexFiltered(ol,ClassMemberHighlight::Typedefs);
  writeClassMemberIndexFiltered(ol,ClassMemberHighlight::Enums);
  writeClassMemberIndexFiltered(ol,ClassMemberHighlight::EnumValues);
  writeClassMemberIndexFiltered(ol,ClassMemberHighlight::Properties);
  writeClassMemberIndexFiltered(ol,ClassMemberHighlight::Events);
  writeClassMemberIndexFiltered(ol,ClassMemberHighlight::Related);
  if (index.numDocumentedClassMembers(ClassMemberHighlight::All)>0 && addToIndex)
  {
    Doxygen::indexList->decContentsDepth();
  }
 
}

Referenced by writeIndexHierarchyEntries().

◆ writeClassMemberIndexFiltered()

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

static

Definition at line 3102 of file index.cpp.

{
  const auto &index = Index::instance();
  if (index.numDocumentedClassMembers(hl)==0) return;
 
  bool disableIndex     = Config_getBool(DISABLE_INDEX);
  bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
  bool fullSidebar      = Config_getBool(FULL_SIDEBAR);
  bool quickLinksAfterSplitbar = !disableIndex && generateTreeView && fullSidebar;
 
  bool multiPageIndex=FALSE;
  if (index.numDocumentedClassMembers(hl)>MAX_ITEMS_BEFORE_MULTIPAGE_INDEX)
  {
    multiPageIndex=TRUE;
  }
 
  ol.pushGeneratorState();
  ol.disableAllBut(OutputType::Html);
 
  QCString extension=Doxygen::htmlFileExtension;
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassMembers);
  QCString title = lne ? lne->title() : theTranslator->trCompoundMembers();
  if (hl!=ClassMemberHighlight::All) title+=QCString(" - ")+getCmhlInfo(hl)->title;
  bool addToIndex = lne==nullptr || lne->visible();
 
  if (addToIndex)
  {
    Doxygen::indexList->addContentsItem(multiPageIndex,getCmhlInfo(hl)->title,QCString(),
        getCmhlInfo(hl)->fname,QCString(),multiPageIndex,TRUE);
    if (multiPageIndex) Doxygen::indexList->incContentsDepth();
  }
 
  bool first=TRUE;
  for (const auto &[letter,list] : index.isClassIndexLetterUsed(hl))
  {
    QCString fileName = getCmhlInfo(hl)->fname;
    if (multiPageIndex)
    {
      QCString cs(letter);
      if (!first)
      {
        fileName+="_"+letterToLabel(cs);
      }
      if (addToIndex)
      {
        Doxygen::indexList->addContentsItem(FALSE,cs,QCString(),fileName,QCString(),FALSE,TRUE);
      }
    }
 
    bool quickIndex = index.numDocumentedClassMembers(hl)>maxItemsBeforeQuickIndex;
 
    auto writeQuickLinks = [&,cap_letter=letter]()
    {
      ol.writeQuickLinks(HighlightedItem::Functions,QCString());
      if (!Config_getBool(HTML_DYNAMIC_MENUS))
      {
        startQuickIndexList(ol);
 
        // index item for global member list
        startQuickIndexItem(ol,
            getCmhlInfo(0)->fname+Doxygen::htmlFileExtension,hl==ClassMemberHighlight::All,TRUE,first);
        ol.writeString(fixSpaces(getCmhlInfo(0)->title));
        endQuickIndexItem(ol);
 
        // index items per category member lists
        for (int i=1;i<ClassMemberHighlight::Total;i++)
        {
          if (index.numDocumentedClassMembers(static_cast<ClassMemberHighlight::Enum>(i))>0)
          {
            startQuickIndexItem(ol,getCmhlInfo(i)->fname+Doxygen::htmlFileExtension,hl==i,TRUE,first);
            ol.writeString(fixSpaces(getCmhlInfo(i)->title));
            //printf("multiPageIndex=%d first=%d fileName=%s file=%s title=%s\n",
            //    multiPageIndex,first,qPrint(fileName),getCmhlInfo(i)->fname,qPrint(getCmhlInfo(i)->title));
            endQuickIndexItem(ol);
          }
        }
 
        endQuickIndexList(ol);
 
        // quick alphabetical index
        if (quickIndex)
        {
          writeQuickMemberIndex(ol,index.isClassIndexLetterUsed(hl),cap_letter,
              getCmhlInfo(hl)->fname,multiPageIndex);
        }
      }
    };
 
    ol.startFile(fileName+extension,QCString(),title);
    ol.startQuickIndices();
    if (!disableIndex && !quickLinksAfterSplitbar)
    {
      writeQuickLinks();
    }
    ol.endQuickIndices();
    ol.writeSplitBar(fileName);
    if (quickLinksAfterSplitbar)
    {
      writeQuickLinks();
    }
    ol.writeSearchInfo();
 
    ol.startContents();
 
    ol.startTextBlock();
    ol.parseText(hl == ClassMemberHighlight::All && lne ? lne->intro() : theTranslator->trCompoundMembersDescriptionTotal(hl));
    ol.endTextBlock();
 
    writeMemberList(ol,quickIndex,
        multiPageIndex ? letter : std::string(),
        index.isClassIndexLetterUsed(hl),
        Definition::TypeClass);
    endFile(ol);
    first=FALSE;
  }
 
  if (multiPageIndex && addToIndex) Doxygen::indexList->decContentsDepth();
 
  ol.popGeneratorState();
}

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>

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

static

Definition at line 1694 of file index.cpp.

{
  bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
  for (const auto &cdi : cl)
  {
    const ClassDef *cd = get_pointer(cdi);
    if (cd->getLanguage()==SrcLangExt::VHDL)
    {
      if (VhdlDocGen::convert(cd->protection())==VhdlDocGen::PACKAGECLASS ||
          VhdlDocGen::convert(cd->protection())==VhdlDocGen::PACKBODYCLASS
         )// no architecture
      {
        continue;
      }
    }
 
    if (sliceOpt && cd->compoundType() != ct)
    {
      continue;
    }
 
    if (!globalOnly ||
         cd->getOuterScope()==nullptr ||
         cd->getOuterScope()==Doxygen::globalScope
       )
    {
      int count=0;
      for (const auto &ccd : cd->getClasses())
      {
        if (ccd->isLinkableInProject() && !ccd->isImplicitTemplateInstance())
        {
          count++;
        }
      }
      if (classVisibleInIndex(cd) && !cd->isImplicitTemplateInstance())
      {
        if (ftv)
        {
          ftv->addContentsItem(count>0,cd->displayName(FALSE),cd->getReference(),
                               cd->getOutputFileBase(),cd->anchor(),FALSE,TRUE,cd);
        }
        if (addToIndex &&
            (cd->getOuterScope()==nullptr ||
             cd->getOuterScope()->definitionType()!=Definition::TypeClass
            )
           )
        {
          addMembersToIndex(cd,LayoutDocManager::Class,
                            cd->displayName(FALSE),
                            cd->anchor(),
                            cd->partOfGroups().empty() && !cd->isSimple());
        }
        if (count>0)
        {
          if (ftv) ftv->incContentsDepth();
          writeClassTree(cd->getClasses(),ftv,addToIndex,FALSE,ct);
          if (ftv) ftv->decContentsDepth();
        }
      }
    }
  }
}

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, VHDL, and writeClassTree().

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

◆ writeClassTreeForList()

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

static

Definition at line 959 of file index.cpp.

{
  bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
  for (const auto &cd : cl)
  {
    //printf("class %s classHasVisibleRoot=%d isVisibleInHierarchy=%d\n",
    //             qPrint(cd->name()),
    //              classHasVisibleRoot(cd->baseClasses()),
    //              cd->isVisibleInHierarchy()
    //      );
    bool b = false;
    if (cd->getLanguage()==SrcLangExt::VHDL)
    {
      if (VhdlDocGen::convert(cd->protection())!=VhdlDocGen::ENTITYCLASS)
      {
        continue;
      }
      b=!classHasVisibleRoot(cd->subClasses());
    }
    else if (sliceOpt && cd->compoundType() != ct)
    {
      continue;
    }
    else
    {
      b=!classHasVisibleRoot(cd->baseClasses());
    }
 
    if (b)  //filter on root classes
    {
      if (cd->isVisibleInHierarchy()) // should it be visible
      {
        if (!started)
        {
          startIndexHierarchy(ol,0);
          if (addToIndex)
          {
            Doxygen::indexList->incContentsDepth();
          }
          started=TRUE;
        }
        ol.startIndexListItem();
        bool hasChildren = visitedClasses.find(cd.get())==visitedClasses.end() &&
                           classHasVisibleChildren(cd.get());
        //printf("list: Has children %s: %d\n",qPrint(cd->name()),hasChildren);
        if (cd->isLinkable())
        {
          //printf("Writing class %s isLinkable()=%d isLinkableInProject()=%d cd->isImplicitTemplateinstance()=%d\n",
          //    qPrint(cd->displayName()),cd->isLinkable(),cd->isLinkableInProject(),cd->isImplicitTemplateInstance());
          ol.startIndexItem(cd->getReference(),cd->getOutputFileBase());
          ol.parseText(cd->displayName());
          ol.endIndexItem(cd->getReference(),cd->getOutputFileBase());
          if (cd->isReference())
          {
            ol.startTypewriter();
            ol.docify(" [external]");
            ol.endTypewriter();
          }
          if (addToIndex)
          {
            if (cd->getLanguage()!=SrcLangExt::VHDL) // prevents double insertion in Design Unit List
                  Doxygen::indexList->addContentsItem(hasChildren,cd->displayName(),cd->getReference(),cd->getOutputFileBase(),cd->anchor(),FALSE,FALSE);
          }
          if (ftv)
          {
            ftv->addContentsItem(hasChildren,cd->displayName(),cd->getReference(),cd->getOutputFileBase(),cd->anchor(),FALSE,FALSE,cd.get());
          }
        }
        else
        {
          ol.startIndexItem(QCString(),QCString());
          ol.parseText(cd->displayName());
          ol.endIndexItem(QCString(),QCString());
          if (addToIndex)
          {
            Doxygen::indexList->addContentsItem(hasChildren,cd->displayName(),QCString(),QCString(),QCString(),FALSE,FALSE);
          }
          if (ftv)
          {
            ftv->addContentsItem(hasChildren,cd->displayName(),QCString(),QCString(),QCString(),FALSE,FALSE,cd.get());
          }
        }
        if (cd->getLanguage()==SrcLangExt::VHDL && hasChildren)
        {
          writeClassTreeToOutput(ol,cd->baseClasses(),1,ftv,addToIndex,visitedClasses);
          visitedClasses.insert(cd.get());
        }
        else if (hasChildren)
        {
          writeClassTreeToOutput(ol,cd->subClasses(),1,ftv,addToIndex,visitedClasses);
          visitedClasses.insert(cd.get());
        }
        ol.endIndexListItem();
      }
    }
  }
}

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, VHDL, and writeClassTreeToOutput().

Referenced by writeClassHierarchy().

◆ writeClassTreeInsideNamespace() [1/2]

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

static

Definition at line 1982 of file index.cpp.

{
  for (const auto &nd : nsLinkedMap)
  {
    writeClassTreeInsideNamespaceElement(nd.get(),ftv,rootOnly,addToIndex,ct);
  }
}

References writeClassTreeInsideNamespaceElement().

◆ writeClassTreeInsideNamespace() [2/2]

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

static

Definition at line 1973 of file index.cpp.

{
  for (const auto &nd : nsLinkedMap)
  {
    writeClassTreeInsideNamespaceElement(nd,ftv,rootOnly,addToIndex,ct);
  }
}

References writeClassTreeInsideNamespaceElement().

Referenced by writeAnnotatedIndexGeneric(), and writeClassTreeInsideNamespaceElement().

◆ writeClassTreeInsideNamespaceElement()

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

static

Definition at line 1901 of file index.cpp.

{
  bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
  if (!nd->isAnonymous() &&
      (!rootOnly || nd->getOuterScope()==Doxygen::globalScope))
  {
    bool isDir = namespaceHasNestedClass(nd,sliceOpt,ct);
    bool isLinkable  = nd->isLinkableInProject();
 
    //printf("writeClassTreeInsideNamespaceElement namespace %s isLinkable=%d isDir=%d\n",qPrint(nd->name()),isLinkable,isDir);
 
    QCString ref;
    QCString file;
    if (isLinkable)
    {
      ref  = nd->getReference();
      file = nd->getOutputFileBase();
      if (nd->getLanguage()==SrcLangExt::VHDL) // UGLY HACK
      {
        file=file.replace(0,qstrlen("namespace"),"class");
      }
    }
 
    if (isDir)
    {
      ftv->addContentsItem(isDir,nd->localName(),ref,file,QCString(),FALSE,TRUE,nd);
 
      if (addToIndex)
      {
        // the namespace entry is already shown under the namespace list so don't
        // add it to the nav index and don't create a separate index file for it otherwise
        // it will overwrite the one written for the namespace list.
        Doxygen::indexList->addContentsItem(isDir,nd->localName(),ref,file,QCString(),
            false, // separateIndex
            false  // addToNavIndex
            );
      }
      if (addToIndex)
      {
        Doxygen::indexList->incContentsDepth();
      }
 
      ftv->incContentsDepth();
      writeClassTreeInsideNamespace(nd->getNamespaces(),ftv,FALSE,addToIndex,ct);
      ClassLinkedRefMap d = nd->getClasses();
      if (sliceOpt)
      {
        if (ct == ClassDef::Interface)
        {
          d = nd->getInterfaces();
        }
        else if (ct == ClassDef::Struct)
        {
          d = nd->getStructs();
        }
        else if (ct == ClassDef::Exception)
        {
          d = nd->getExceptions();
        }
      }
      writeClassTree(d,ftv,addToIndex,FALSE,ct);
      ftv->decContentsDepth();
 
      if (addToIndex)
      {
        Doxygen::indexList->decContentsDepth();
      }
    }
  }
}

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, VHDL, writeClassTree(), and writeClassTreeInsideNamespace().

Referenced by writeClassTreeInsideNamespace(), and writeClassTreeInsideNamespace().

◆ writeClassTreeToOutput()

static 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 615 of file index.cpp.

{
  if (bcl.empty()) return;
  bool started=FALSE;
  for (const auto &bcd : bcl)
  {
    ClassDef *cd=bcd.classDef;
    if (cd->getLanguage()==SrcLangExt::VHDL && VhdlDocGen::convert(cd->protection())!=VhdlDocGen::ENTITYCLASS)
    {
      continue;
    }
 
    bool b = cd->getLanguage()==SrcLangExt::VHDL ? classHasVisibleRoot(cd->subClasses()) : classHasVisibleRoot(cd->baseClasses());
 
    if (cd->isVisibleInHierarchy() && b) // classHasVisibleRoot(cd->baseClasses()))
    {
      if (!started)
      {
        startIndexHierarchy(ol,level);
        if (addToIndex)
        {
          Doxygen::indexList->incContentsDepth();
        }
        if (ftv)
        {
          ftv->incContentsDepth();
        }
        started=TRUE;
      }
      ol.startIndexListItem();
      //printf("Passed...\n");
      bool hasChildren = visitedClasses.find(cd)==visitedClasses.end() &&
                         classHasVisibleChildren(cd);
      //printf("tree4: Has children %s: %d\n",qPrint(cd->name()),hasChildren);
      if (cd->isLinkable())
      {
        //printf("Writing class %s\n",qPrint(cd->displayName()));
        ol.startIndexItem(cd->getReference(),cd->getOutputFileBase());
        ol.parseText(cd->displayName());
        ol.endIndexItem(cd->getReference(),cd->getOutputFileBase());
        if (cd->isReference())
        {
          ol.startTypewriter();
          ol.docify(" [external]");
          ol.endTypewriter();
        }
        if (addToIndex)
        {
          Doxygen::indexList->addContentsItem(hasChildren,cd->displayName(),cd->getReference(),cd->getOutputFileBase(),cd->anchor());
        }
        if (ftv)
        {
          if (cd->getLanguage()==SrcLangExt::VHDL)
          {
            ftv->addContentsItem(hasChildren,bcd.usedName,cd->getReference(),cd->getOutputFileBase(),cd->anchor(),FALSE,FALSE,cd);
          }
          else
          {
            ftv->addContentsItem(hasChildren,cd->displayName(),cd->getReference(),cd->getOutputFileBase(),cd->anchor(),FALSE,FALSE,cd);
          }
        }
      }
      else
      {
        ol.startIndexItem(QCString(),QCString());
        ol.parseText(cd->name());
        ol.endIndexItem(QCString(),QCString());
        if (addToIndex)
        {
          Doxygen::indexList->addContentsItem(hasChildren,cd->displayName(),QCString(),QCString(),QCString());
        }
        if (ftv)
        {
          ftv->addContentsItem(hasChildren,cd->displayName(),QCString(),QCString(),QCString(),FALSE,FALSE,cd);
        }
      }
      if (hasChildren)
      {
        //printf("Class %s at %p visited=%d\n",qPrint(cd->name()),cd,cd->visited);
        visitedClasses.insert(cd);
        if (cd->getLanguage()==SrcLangExt::VHDL)
        {
          writeClassTreeToOutput(ol,cd->baseClasses(),level+1,ftv,addToIndex,visitedClasses);
        }
        else
        {
          writeClassTreeToOutput(ol,cd->subClasses(),level+1,ftv,addToIndex,visitedClasses);
        }
      }
      ol.endIndexListItem();
    }
  }
  if (started)
  {
    endIndexHierarchy(ol,level);
    if (addToIndex)
    {
      Doxygen::indexList->decContentsDepth();
    }
    if (ftv)
    {
      ftv->decContentsDepth();
    }
  }
}

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, VHDL, and writeClassTreeToOutput().

Referenced by writeClassTreeForList(), and writeClassTreeToOutput().

◆ writeConceptIndex()

static void writeConceptIndex ( OutputList & ol )

static

Definition at line 4619 of file index.cpp.

{
  if (Index::instance().numDocumentedConcepts()==0) return;
  ol.pushGeneratorState();
  // 1.{
  ol.disable(OutputType::Man);
  ol.disable(OutputType::Docbook);
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Concepts);
  QCString title = lne ? lne->title() : theTranslator->trConceptList();
  bool addToIndex = lne==nullptr || lne->visible();
 
  startFile(ol,"concepts",QCString(),title,HighlightedItem::Concepts);
  startTitle(ol,QCString());
  ol.parseText(title);
  endTitle(ol,QCString(),QCString());
  ol.startContents();
  ol.startTextBlock();
  ol.parseText(lne ? lne->intro() : theTranslator->trConceptListDescription(Config_getBool(EXTRACT_ALL)));
  ol.endTextBlock();
 
  // ---------------
  // Normal group index for Latex/RTF
  // ---------------
  // 2.{
  ol.pushGeneratorState();
  ol.disable(OutputType::Html);
 
  bool first=TRUE;
  for (const auto &cd : *Doxygen::conceptLinkedMap)
  {
    if (cd->isLinkableInProject())
    {
      if (first)
      {
        ol.startIndexList();
        first=FALSE;
      }
      //ol.writeStartAnnoItem("namespace",nd->getOutputFileBase(),0,nd->name());
      ol.startIndexKey();
      ol.writeObjectLink(QCString(),cd->getOutputFileBase(),QCString(),cd->displayName());
      ol.endIndexKey();
 
      bool hasBrief = !cd->briefDescription().isEmpty();
      ol.startIndexValue(hasBrief);
      if (hasBrief)
      {
        //ol.docify(" (");
        ol.generateDoc(
                 cd->briefFile(),cd->briefLine(),
                 cd.get(),nullptr,
                 cd->briefDescription(TRUE),
                 FALSE, // index words
                 FALSE, // isExample
                 QCString(),     // example name
                 TRUE,  // single line
                 TRUE,  // link from index
                 Config_getBool(MARKDOWN_SUPPORT)
                );
        //ol.docify(")");
      }
      ol.endIndexValue(cd->getOutputFileBase(),hasBrief);
 
    }
  }
  if (!first) ol.endIndexList();
 
  ol.popGeneratorState();
  // 2.}
 
  // ---------------
  // interactive group index for HTML
  // ---------------
  // 2.{
  ol.pushGeneratorState();
  ol.disableAllBut(OutputType::Html);
 
  {
    if (addToIndex)
    {
      Doxygen::indexList->addContentsItem(TRUE,title,QCString(),"concepts",QCString(),TRUE,TRUE);
      Doxygen::indexList->incContentsDepth();
    }
    FTVHelp ftv(false);
    for (const auto &nd : *Doxygen::namespaceLinkedMap)
    {
      writeConceptTreeInsideNamespaceElement(nd.get(),&ftv,true,addToIndex);
    }
    writeConceptRootList(&ftv,addToIndex);
    TextStream t;
    ftv.generateTreeViewInline(t);
    ol.writeString(t.str().c_str());
    if (addToIndex)
    {
      Doxygen::indexList->decContentsDepth();
    }
  }
  ol.popGeneratorState();
  // 2.}
 
  endFile(ol);
  ol.popGeneratorState();
  // 1.}
}

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()

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

static

Definition at line 4513 of file index.cpp.

{
  for (const auto &cd : concepts)
  {
    if (cd->isLinkableInProject())
    {
      if (ftv)
      {
        ftv->addContentsItem(false,cd->displayName(FALSE),cd->getReference(),
                             cd->getOutputFileBase(),QCString(),false,cd->partOfGroups().empty(),cd);
      }
      if (addToIndex)
      {
        Doxygen::indexList->addContentsItem(false,cd->displayName(FALSE),cd->getReference(),
            cd->getOutputFileBase(),QCString(),false,cd->partOfGroups().empty());
      }
    }
  }
}

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

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

◆ writeConceptRootList()

static void writeConceptRootList	(	FTVHelp *	ftv,
		bool	addToIndex )

static

Definition at line 4597 of file index.cpp.

{
  for (const auto &cd : *Doxygen::conceptLinkedMap)
  {
    if ((cd->getOuterScope()==nullptr ||
        cd->getOuterScope()==Doxygen::globalScope) && cd->isLinkableInProject()
       )
    {
      //printf("*** adding %s hasSubPages=%d hasSections=%d\n",qPrint(pageTitle),hasSubPages,hasSections);
      ftv->addContentsItem(
          false,cd->localName(),cd->getReference(),cd->getOutputFileBase(),
          QCString(),false,cd->partOfGroups().empty(),cd.get());
      if (addToIndex)
      {
        Doxygen::indexList->addContentsItem(
            false,cd->localName(),cd->getReference(),cd->getOutputFileBase(),
            QCString(),false,cd->partOfGroups().empty(),cd.get());
      }
    }
  }
}

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

Referenced by writeConceptIndex().

◆ writeConceptTreeInsideNamespace()

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

static

Definition at line 4536 of file index.cpp.

{
  for (const auto &nd : nsLinkedMap)
  {
    writeConceptTreeInsideNamespaceElement(nd,ftv,rootOnly,addToIndex);
  }
}

References writeConceptTreeInsideNamespaceElement().

Referenced by writeConceptTreeInsideNamespaceElement().

◆ writeConceptTreeInsideNamespaceElement()

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

static

Definition at line 4546 of file index.cpp.

{
  if (!nd->isAnonymous() &&
      (!rootOnly || nd->getOuterScope()==Doxygen::globalScope))
  {
    bool isDir = namespaceHasNestedConcept(nd);
    bool isLinkable  = nd->isLinkableInProject();
 
    //printf("writeConceptTreeInsideNamespaceElement namespace %s isLinkable=%d isDir=%d\n",qPrint(nd->name()),isLinkable,isDir);
 
    QCString ref;
    QCString file;
    if (isLinkable)
    {
      ref  = nd->getReference();
      file = nd->getOutputFileBase();
    }
 
    if (isDir)
    {
      ftv->addContentsItem(isDir,nd->localName(),ref,file,QCString(),FALSE,TRUE,nd);
 
      if (addToIndex)
      {
        // the namespace entry is already shown under the namespace list so don't
        // add it to the nav index and don't create a separate index file for it otherwise
        // it will overwrite the one written for the namespace list.
        Doxygen::indexList->addContentsItem(isDir,nd->localName(),ref,file,QCString(),
            false, // separateIndex
            false  // addToNavIndex
            );
      }
      if (addToIndex)
      {
        Doxygen::indexList->incContentsDepth();
      }
 
      ftv->incContentsDepth();
      writeConceptTreeInsideNamespace(nd->getNamespaces(),ftv,FALSE,addToIndex);
      writeConceptList(nd->getConcepts(),ftv,addToIndex);
      ftv->decContentsDepth();
 
      if (addToIndex)
      {
        Doxygen::indexList->decContentsDepth();
      }
    }
  }
}

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()

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

static

Definition at line 895 of file index.cpp.

{
  if (ftv)
  {
    ol.pushGeneratorState();
    ol.disable(OutputType::Html);
  }
  startIndexHierarchy(ol,0);
  for (const auto &dd : *Doxygen::dirLinkedMap)
  {
    if (dd->getOuterScope()==Doxygen::globalScope)
    {
      writeDirTreeNode(ol,dd.get(),0,ftv,addToIndex);
    }
  }
  if (ftv)
  {
    for (const auto &fn : *Doxygen::inputNameLinkedMap)
    {
      for (const auto &fd : *fn)
      {
        if (fd->getDirDef()==nullptr) // top level file
        {
          bool src = false;
          bool doc = fileVisibleInIndex(fd.get(),src);
          QCString reference, outputBase;
          if (doc)
          {
            reference = fd->getReference();
            outputBase = fd->getOutputFileBase();
          }
          if (doc || src)
          {
            ftv->addContentsItem(FALSE,fd->displayName(),
                                 reference, outputBase, QCString(),
                                 FALSE,FALSE,fd.get());
          }
          if (addToIndex)
          {
            if (doc)
            {
              addMembersToIndex(fd.get(),LayoutDocManager::File,fd->displayName(),QCString(),TRUE,FALSE,&fd->getConcepts());
            }
            else if (src)
            {
              Doxygen::indexList->addContentsItem(
                  FALSE, fd->displayName(), QCString(),
                  fd->getSourceFileBase(), QCString(), FALSE, TRUE, fd.get());
            }
          }
        }
      }
    }
  }
  endIndexHierarchy(ol,0);
  if (ftv)
  {
    ol.popGeneratorState();
  }
}

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().

◆ writeDirTreeNode()

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

static

Definition at line 751 of file index.cpp.

{
  if (level>20)
  {
    warn(dd->getDefFileName(),dd->getDefLine(),
        "maximum nesting level exceeded for directory {}: "
        "check for possible recursive directory relation!",dd->name());
    return;
  }
 
  if (!dirHasVisibleChildren(dd))
  {
    return;
  }
 
  bool tocExpand = TRUE; //Config_getBool(TOC_EXPAND);
  bool isDir = !dd->subDirs().empty() ||  // there are subdirs
               (tocExpand &&              // or toc expand and
                !dd->getFiles().empty()   // there are files
               );
  //printf("gd='%s': pageDict=%d\n",qPrint(gd->name()),gd->pageDict->count());
  if (addToIndex)
  {
    Doxygen::indexList->addContentsItem(isDir,dd->shortName(),dd->getReference(),dd->getOutputFileBase(),QCString(),TRUE,TRUE);
    Doxygen::indexList->incContentsDepth();
  }
  if (ftv)
  {
    ftv->addContentsItem(isDir,dd->shortName(),dd->getReference(),
                         dd->getOutputFileBase(),QCString(),FALSE,TRUE,dd);
    ftv->incContentsDepth();
  }
 
  ol.startIndexListItem();
  ol.startIndexItem(dd->getReference(),dd->getOutputFileBase());
  ol.parseText(dd->shortName());
  ol.endIndexItem(dd->getReference(),dd->getOutputFileBase());
  if (dd->isReference())
  {
    ol.startTypewriter();
    ol.docify(" [external]");
    ol.endTypewriter();
  }
 
  // write sub directories
  if (dd->subDirs().size()>0)
  {
    startIndexHierarchy(ol,level+1);
    for(const auto &subdd : dd->subDirs())
    {
      writeDirTreeNode(ol,subdd,level+1,ftv,addToIndex);
    }
    endIndexHierarchy(ol,level+1);
  }
 
  int fileCount=0;
  if (!dd->getFiles().empty())
  {
    for (const auto &fd : dd->getFiles())
    {
      //bool allExternals = Config_getBool(ALLEXTERNALS);
      //if ((allExternals && fd->isLinkable()) || fd->isLinkableInProject())
      //{
      //  fileCount++;
      //}
      bool genSourceFile = false;
      if (fileVisibleInIndex(fd,genSourceFile))
      {
        fileCount++;
      }
      else if (genSourceFile)
      {
        fileCount++;
      }
    }
    if (fileCount>0)
    {
      startIndexHierarchy(ol,level+1);
      for (const auto &fd : dd->getFiles())
      {
        bool src = false;
        bool doc = fileVisibleInIndex(fd,src);
        QCString reference;
        QCString outputBase;
        if (doc)
        {
          reference  = fd->getReference();
          outputBase = fd->getOutputFileBase();
        }
        if (doc || src)
        {
          ol.startIndexListItem();
          ol.startIndexItem(reference,outputBase);
          ol.parseText(fd->displayName());
          ol.endIndexItem(reference,outputBase);
          ol.endIndexListItem();
          if (ftv && (src || doc))
          {
            ftv->addContentsItem(FALSE,
                fd->displayName(),
                reference,outputBase,
                QCString(),FALSE,FALSE,fd);
          }
        }
      }
      endIndexHierarchy(ol,level+1);
    }
  }
 
  if (tocExpand && addToIndex)
  {
    // write files of this directory
    if (fileCount>0)
    {
      for (const auto &fd : dd->getFiles())
      {
        bool src = false;
        bool doc = fileVisibleInIndex(fd,src);
        if (doc)
        {
          addMembersToIndex(fd,LayoutDocManager::File,fd->displayName(),QCString(),
                            !fd->isLinkableViaGroup(),FALSE,&fd->getConcepts());
        }
        else if (src)
        {
          Doxygen::indexList->addContentsItem(
               FALSE, fd->name(), QCString(),
               fd->getSourceFileBase(), QCString(), FALSE, TRUE, fd);
        }
      }
    }
  }
  ol.endIndexListItem();
 
  if (addToIndex)
  {
    Doxygen::indexList->decContentsDepth();
  }
  if (ftv)
  {
    ftv->decContentsDepth();
  }
}

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(), and writeDirTreeNode().

◆ writeExampleIndex()

static void writeExampleIndex ( OutputList & ol )

static

Definition at line 3772 of file index.cpp.

{
  if (Doxygen::exampleLinkedMap->empty()) return;
  ol.pushGeneratorState();
  ol.disable(OutputType::Man);
  ol.disable(OutputType::Docbook);
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Examples);
  QCString title = lne ? lne->title() : theTranslator->trExamples();
  bool addToIndex = lne==nullptr || lne->visible();
 
  startFile(ol,"examples",QCString(),title,HighlightedItem::Examples);
 
  startTitle(ol,QCString());
  ol.parseText(title);
  endTitle(ol,QCString(),QCString());
 
  ol.startContents();
 
  if (addToIndex)
  {
    Doxygen::indexList->addContentsItem(TRUE,title,QCString(),"examples",QCString(),TRUE,TRUE);
    Doxygen::indexList->incContentsDepth();
  }
 
  ol.startTextBlock();
  ol.parseText(lne ? lne->intro() : theTranslator->trExamplesDescription());
  ol.endTextBlock();
 
  ol.startItemList();
  for (const auto &pd : *Doxygen::exampleLinkedMap)
  {
    ol.startItemListItem();
    QCString n=pd->getOutputFileBase();
    if (!pd->title().isEmpty())
    {
      ol.writeObjectLink(QCString(),n,QCString(),pd->title());
      if (addToIndex)
      {
        Doxygen::indexList->addContentsItem(FALSE,filterTitle(pd->title()),pd->getReference(),n,QCString(),FALSE,TRUE);
      }
    }
    else
    {
      ol.writeObjectLink(QCString(),n,QCString(),pd->name());
      if (addToIndex)
      {
        Doxygen::indexList->addContentsItem(FALSE,pd->name(),pd->getReference(),n,QCString(),FALSE,TRUE);
      }
    }
    ol.endItemListItem();
    //ol.writeString("\n");
  }
  ol.endItemList();
 
  if (addToIndex)
  {
    Doxygen::indexList->decContentsDepth();
  }
  endFile(ol);
  ol.popGeneratorState();
}

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()

static void writeFileIndex ( OutputList & ol )

static

Definition at line 1538 of file index.cpp.

{
  if (Index::instance().numDocumentedFiles()==0 || !Config_getBool(SHOW_FILES)) return;
 
  ol.pushGeneratorState();
  ol.disable(OutputType::Man);
  ol.disable(OutputType::Docbook);
 
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::FileList);
  if (lne==nullptr) lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Files); // fall back
  QCString title = lne ? lne->title() : theTranslator->trFileList();
  bool addToIndex = lne==nullptr || lne->visible();
 
  startFile(ol,"files",QCString(),title,HighlightedItem::Files);
  startTitle(ol,QCString());
  //if (!Config_getString(PROJECT_NAME).isEmpty())
  //{
  //  title.prepend(Config_getString(PROJECT_NAME)+" ");
  //}
  ol.parseText(title);
  endTitle(ol,QCString(),QCString());
  ol.startContents();
  ol.startTextBlock();
 
  if (addToIndex)
  {
    Doxygen::indexList->addContentsItem(TRUE,title,QCString(),"files",QCString(),TRUE,TRUE);
    Doxygen::indexList->incContentsDepth();
  }
 
  ol.parseText(lne ? lne->intro() : theTranslator->trFileListDescription(Config_getBool(EXTRACT_ALL)));
  ol.endTextBlock();
 
  // ---------------
  // Flat file index
  // ---------------
 
  // 1. {
  ol.pushGeneratorState();
  ol.disable(OutputType::Html);
 
  ol.startIndexList();
  if (Config_getBool(FULL_PATH_NAMES))
  {
    std::unordered_map<std::string,size_t> pathMap;
    std::vector<FilesInDir> outputFiles;
 
    // re-sort input files in (dir,file) output order instead of (file,dir) input order
    for (const auto &fn : *Doxygen::inputNameLinkedMap)
    {
      for (const auto &fd : *fn)
      {
        QCString path=fd->getPath();
        if (path.isEmpty()) path="[external]";
        auto it = pathMap.find(path.str());
        if (it!=pathMap.end()) // existing path -> append
        {
          outputFiles.at(it->second).files.push_back(fd.get());
        }
        else // new path -> create path entry + append
        {
          pathMap.emplace(path.str(),outputFiles.size());
          outputFiles.emplace_back(path);
          outputFiles.back().files.push_back(fd.get());
        }
      }
    }
 
    // sort the files by path
    std::stable_sort(outputFiles.begin(),
              outputFiles.end(),
              [](const auto &fp1,const auto &fp2) { return qstricmp_sort(fp1.path,fp2.path)<0; });
    // sort the files inside the directory by name
    for (auto &fp : outputFiles)
    {
      std::stable_sort(fp.files.begin(), fp.files.end(), compareFileDefs);
    }
    // write the results
    for (const auto &fp : outputFiles)
    {
      for (const auto &fd : fp.files)
      {
        writeSingleFileIndex(ol,fd);
      }
    }
  }
  else
  {
    for (const auto &fn : *Doxygen::inputNameLinkedMap)
    {
     for (const auto &fd : *fn)
      {
        writeSingleFileIndex(ol,fd.get());
      }
    }
  }
  ol.endIndexList();
 
  // 1. }
  ol.popGeneratorState();
 
  // ---------------
  // Hierarchical file index for HTML
  // ---------------
  ol.pushGeneratorState();
  ol.disableAllBut(OutputType::Html);
 
  {
    FTVHelp ftv(false);
    writeDirHierarchy(ol,&ftv,addToIndex);
    TextStream t;
    ftv.generateTreeViewInline(t);
    ol.writeString(t.str().c_str());
  }
 
  ol.popGeneratorState();
  // ------
 
  if (addToIndex)
  {
    Doxygen::indexList->decContentsDepth();
  }
 
  endFile(ol);
  ol.popGeneratorState();
}

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()

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

static

Definition at line 2690 of file index.cpp.

{
  const FileDef *fd=md->getFileDef();
  if (fd && prevFileName!=fd->name())
  {
    ol.writeString(separator);
    ol.writeObjectLink(md->getReference(),md->getOutputFileBase(),md->anchor(),
        fd->name());
    prevFileName = fd->name();
  }
}

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

Referenced by writeMemberList().

◆ writeFileMemberIndex()

static void writeFileMemberIndex ( OutputList & ol )

static

Definition at line 3399 of file index.cpp.

{
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::FileGlobals);
  bool addToIndex = lne==nullptr || lne->visible();
  if (Index::instance().numDocumentedFileMembers(FileMemberHighlight::All)>0 && addToIndex)
  {
    Doxygen::indexList->addContentsItem(true,lne ? lne->title() : theTranslator->trFileMembers(),QCString(),"globals",QCString());
    Doxygen::indexList->incContentsDepth();
  }
  writeFileMemberIndexFiltered(ol,FileMemberHighlight::All);
  writeFileMemberIndexFiltered(ol,FileMemberHighlight::Functions);
  writeFileMemberIndexFiltered(ol,FileMemberHighlight::Variables);
  writeFileMemberIndexFiltered(ol,FileMemberHighlight::Typedefs);
  writeFileMemberIndexFiltered(ol,FileMemberHighlight::Sequences);
  writeFileMemberIndexFiltered(ol,FileMemberHighlight::Dictionaries);
  writeFileMemberIndexFiltered(ol,FileMemberHighlight::Enums);
  writeFileMemberIndexFiltered(ol,FileMemberHighlight::EnumValues);
  writeFileMemberIndexFiltered(ol,FileMemberHighlight::Defines);
  if (Index::instance().numDocumentedFileMembers(FileMemberHighlight::All)>0 && addToIndex)
  {
    Doxygen::indexList->decContentsDepth();
  }
 
}

Referenced by writeIndexHierarchyEntries().

◆ writeFileMemberIndexFiltered()

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

static

Definition at line 3283 of file index.cpp.

{
  const auto &index = Index::instance();
  if (index.numDocumentedFileMembers(hl)==0) return;
 
  bool disableIndex     = Config_getBool(DISABLE_INDEX);
  bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
  bool fullSidebar      = Config_getBool(FULL_SIDEBAR);
  bool quickLinksAfterSplitbar = !disableIndex && generateTreeView && fullSidebar;
 
  bool multiPageIndex=FALSE;
  if (Index::instance().numDocumentedFileMembers(hl)>MAX_ITEMS_BEFORE_MULTIPAGE_INDEX)
  {
    multiPageIndex=TRUE;
  }
 
  ol.pushGeneratorState();
  ol.disableAllBut(OutputType::Html);
 
  QCString extension=Doxygen::htmlFileExtension;
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::FileGlobals);
  QCString title = lne ? lne->title() : theTranslator->trFileMembers();
  bool addToIndex = lne==nullptr || lne->visible();
 
  if (addToIndex)
  {
    Doxygen::indexList->addContentsItem(multiPageIndex,getFmhlInfo(hl)->title,QCString(),
        getFmhlInfo(hl)->fname,QCString(),multiPageIndex,TRUE);
    if (multiPageIndex) Doxygen::indexList->incContentsDepth();
  }
 
  bool first=TRUE;
  for (const auto &[letter,list] : index.isFileIndexLetterUsed(hl))
  {
    QCString fileName = getFmhlInfo(hl)->fname;
    if (multiPageIndex)
    {
      QCString cs(letter);
      if (!first)
      {
        fileName+="_"+letterToLabel(cs);
      }
      if (addToIndex)
      {
        Doxygen::indexList->addContentsItem(FALSE,cs,QCString(),fileName,QCString(),FALSE,TRUE);
      }
    }
 
    bool quickIndex = index.numDocumentedFileMembers(hl)>maxItemsBeforeQuickIndex;
 
    auto writeQuickLinks = [&,cap_letter=letter]()
    {
      ol.writeQuickLinks(HighlightedItem::Globals,QCString());
      if (!Config_getBool(HTML_DYNAMIC_MENUS))
      {
        startQuickIndexList(ol);
 
        // index item for all file member lists
        startQuickIndexItem(ol,
            getFmhlInfo(0)->fname+Doxygen::htmlFileExtension,hl==FileMemberHighlight::All,TRUE,first);
        ol.writeString(fixSpaces(getFmhlInfo(0)->title));
        endQuickIndexItem(ol);
 
        // index items for per category member lists
        for (int i=1;i<FileMemberHighlight::Total;i++)
        {
          if (Index::instance().numDocumentedFileMembers(static_cast<FileMemberHighlight::Enum>(i))>0)
          {
            startQuickIndexItem(ol,
                getFmhlInfo(i)->fname+Doxygen::htmlFileExtension,hl==i,TRUE,first);
            ol.writeString(fixSpaces(getFmhlInfo(i)->title));
            endQuickIndexItem(ol);
          }
        }
 
        endQuickIndexList(ol);
 
        if (quickIndex)
        {
          writeQuickMemberIndex(ol,index.isFileIndexLetterUsed(hl),cap_letter,
              getFmhlInfo(hl)->fname,multiPageIndex);
        }
      }
    };
 
    ol.startFile(fileName+extension,QCString(),title);
    ol.startQuickIndices();
    if (!disableIndex && !quickLinksAfterSplitbar)
    {
      writeQuickLinks();
    }
    ol.endQuickIndices();
    ol.writeSplitBar(fileName);
    if (quickLinksAfterSplitbar)
    {
      writeQuickLinks();
    }
    ol.writeSearchInfo();
 
    ol.startContents();
 
    ol.startTextBlock();
    ol.parseText(hl == FileMemberHighlight::All && lne ? lne->intro() : theTranslator->trFileMembersDescriptionTotal(hl));
    ol.endTextBlock();
 
    writeMemberList(ol,quickIndex,
        multiPageIndex ? letter : std::string(),
        index.isFileIndexLetterUsed(hl),
        Definition::TypeFile);
    endFile(ol);
    first=FALSE;
  }
  if (multiPageIndex && addToIndex) Doxygen::indexList->decContentsDepth();
  ol.popGeneratorState();
}

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()

static void writeGraphicalClassHierarchy ( OutputList & ol )

static

Definition at line 1200 of file index.cpp.

{
  if (Index::instance().numHierarchyClasses()==0) return;
  ol.disableAllBut(OutputType::Html);
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassHierarchy);
  QCString title = lne ? lne->title() : theTranslator->trClassHierarchy();
  startFile(ol,"inherits",QCString(),title,HighlightedItem::ClassHierarchy,FALSE,"hierarchy");
  startTitle(ol,QCString());
  ol.parseText(title);
  endTitle(ol,QCString(),QCString());
  ol.startContents();
  ol.startTextBlock();
  ol.startParagraph();
  ol.startTextLink("hierarchy",QCString());
  ol.parseText(theTranslator->trGotoTextualHierarchy());
  ol.endTextLink();
  ol.endParagraph();
  ol.endTextBlock();
  DotGfxHierarchyTable g;
  ol.writeGraphicalHierarchy(g);
  endFile(ol);
  ol.enableAll();
}

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()

static void writeGraphicalExceptionHierarchy ( OutputList & ol )

static

Definition at line 1410 of file index.cpp.

{
  if (Index::instance().numHierarchyExceptions()==0) return;
  ol.disableAllBut(OutputType::Html);
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ExceptionHierarchy);
  QCString title = lne ? lne->title() : theTranslator->trExceptionHierarchy();
  startFile(ol,"exceptioninherits",QCString(),title,HighlightedItem::ExceptionHierarchy,FALSE,"exceptionhierarchy");
  startTitle(ol,QCString());
  ol.parseText(title);
  endTitle(ol,QCString(),QCString());
  ol.startContents();
  ol.startTextBlock();
  ol.startParagraph();
  ol.startTextLink("exceptionhierarchy",QCString());
  ol.parseText(theTranslator->trGotoTextualHierarchy());
  ol.endTextLink();
  ol.endParagraph();
  ol.endTextBlock();
  DotGfxHierarchyTable g("exception_",ClassDef::Exception);
  ol.writeGraphicalHierarchy(g);
  endFile(ol);
  ol.enableAll();
}

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()

static void writeGraphicalInterfaceHierarchy ( OutputList & ol )

static

Definition at line 1305 of file index.cpp.

{
  if (Index::instance().numHierarchyInterfaces()==0) return;
  ol.disableAllBut(OutputType::Html);
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::InterfaceHierarchy);
  QCString title = lne ? lne->title() : theTranslator->trInterfaceHierarchy();
  startFile(ol,"interfaceinherits",QCString(),title,HighlightedItem::InterfaceHierarchy,FALSE,"interfacehierarchy");
  startTitle(ol,QCString());
  ol.parseText(title);
  endTitle(ol,QCString(),QCString());
  ol.startContents();
  ol.startTextBlock();
  ol.startParagraph();
  ol.startTextLink("interfacehierarchy",QCString());
  ol.parseText(theTranslator->trGotoTextualHierarchy());
  ol.endTextLink();
  ol.endParagraph();
  ol.endTextBlock();
  DotGfxHierarchyTable g("interface_",ClassDef::Interface);
  ol.writeGraphicalHierarchy(g);
  endFile(ol);
  ol.enableAll();
}

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 4000 of file index.cpp.

{
  if (!Config_getBool(HAVE_DOT) || !Config_getBool(GENERATE_HTML)) return;
  ol.pushGeneratorState();
  ol.disableAllBut(OutputType::Html);
 
  DotLegendGraph gd;
  gd.writeGraph(Config_getString(HTML_OUTPUT));
 
  bool oldStripCommentsState = Config_getBool(STRIP_CODE_COMMENTS);
  bool oldCreateSubdirs = Config_getBool(CREATE_SUBDIRS);
  // temporarily disable the stripping of comments for our own code example!
  Config_updateBool(STRIP_CODE_COMMENTS,FALSE);
  // temporarily disable create subdirs for linking to our example
  Config_updateBool(CREATE_SUBDIRS,FALSE);
 
  startFile(ol,"graph_legend",QCString(),theTranslator->trLegendTitle());
  startTitle(ol,QCString());
  ol.parseText(theTranslator->trLegendTitle());
  endTitle(ol,QCString(),QCString());
  ol.startContents();
  QCString legendDocs = theTranslator->trLegendDocs();
  int s = legendDocs.find("<center>");
  int e = legendDocs.find("</center>");
  QCString imgExt = getDotImageExtension();
  if (imgExt=="svg" && s!=-1 && e!=-1)
  {
    legendDocs = legendDocs.left(s+8) + "[!-- " + "SVG 0 --]" + legendDocs.mid(e);
    //printf("legendDocs=%s\n",qPrint(legendDocs));
  }
 
  {
    auto fd = createFileDef("","graph_legend.dox");
    ol.generateDoc("graph_legend",1,fd.get(),nullptr,legendDocs,FALSE,FALSE,
        QCString(),FALSE,FALSE,FALSE);
  }
 
  // restore config settings
  Config_updateBool(STRIP_CODE_COMMENTS,oldStripCommentsState);
  Config_updateBool(CREATE_SUBDIRS,oldCreateSubdirs);
 
  endFile(ol);
  ol.popGeneratorState();
}

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()

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

static

Definition at line 4281 of file index.cpp.

{
  if (ftv)
  {
    ol.pushGeneratorState();
    ol.disable(OutputType::Html);
  }
  startIndexHierarchy(ol,0);
  for (const auto &gd : *Doxygen::groupLinkedMap)
  {
    if (gd->isVisibleInHierarchy())
    {
      writeGroupTreeNode(ol,gd.get(),0,ftv,addToIndex);
    }
  }
  endIndexHierarchy(ol,0);
  if (ftv)
  {
    ol.popGeneratorState();
  }
}

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

Referenced by writeTopicIndex().

◆ writeGroupTreeNode()

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

static

write groups as hierarchical trees

Definition at line 4051 of file index.cpp.

{
  //bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
  //bool vhdlOpt    = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
  if (level>20)
  {
    warn(gd->getDefFileName(),gd->getDefLine(),
        "maximum nesting level exceeded for group {}: check for possible recursive group relation!",gd->name());
    return;
  }
 
  /* Some groups should appear twice under different parent-groups.
   * That is why we should not check if it was visited
   */
  if ((!gd->isASubGroup() || level>0) && gd->isVisible() && gd->isVisibleInHierarchy())
  {
    //printf("gd->name()=%s #members=%d\n",qPrint(gd->name()),gd->countMembers());
    // write group info
    bool hasSubGroups = !gd->getSubGroups().empty();
    bool hasSubPages  = !gd->getPages().empty();
    size_t numSubItems = 0;
    for (const auto &ml : gd->getMemberLists())
    {
      if (ml->listType().isDocumentation())
      {
        numSubItems += ml->size();
      }
    }
    numSubItems += gd->getNamespaces().size();
    numSubItems += gd->getClasses().size();
    numSubItems += gd->getFiles().size();
    numSubItems += gd->getConcepts().size();
    numSubItems += gd->getDirs().size();
    numSubItems += gd->getPages().size();
 
    bool isDir = hasSubGroups || hasSubPages || numSubItems>0;
    //printf("gd='%s': pageDict=%d\n",qPrint(gd->name()),gd->pageDict->count());
    if (addToIndex)
    {
      Doxygen::indexList->addContentsItem(isDir,gd->groupTitle(),gd->getReference(),gd->getOutputFileBase(),QCString(),isDir,TRUE);
      Doxygen::indexList->incContentsDepth();
    }
    if (ftv)
    {
      ftv->addContentsItem(hasSubGroups,gd->groupTitle(),
                           gd->getReference(),gd->getOutputFileBase(),QCString(),
                           FALSE,FALSE,gd);
      ftv->incContentsDepth();
    }
 
    //ol.writeListItem();
    //ol.startTextLink(gd->getOutputFileBase(),0);
    //parseText(ol,gd->groupTitle());
    //ol.endTextLink();
 
    ol.startIndexListItem();
    ol.startIndexItem(gd->getReference(),gd->getOutputFileBase());
    ol.parseText(gd->groupTitle());
    ol.endIndexItem(gd->getReference(),gd->getOutputFileBase());
    if (gd->isReference())
    {
      ol.startTypewriter();
      ol.docify(" [external]");
      ol.endTypewriter();
    }
 
    for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Group))
    {
      if (lde->kind()==LayoutDocEntry::MemberDef && addToIndex)
      {
        const LayoutDocEntryMemberDef *lmd = dynamic_cast<const LayoutDocEntryMemberDef*>(lde.get());
        if (lmd)
        {
          MemberList *ml = gd->getMemberList(lmd->type);
          if (ml)
          {
            for (const auto &md : *ml)
            {
              const MemberVector &enumList = md->enumFieldList();
              isDir = !enumList.empty() && md->isEnumerate();
              if (md->isVisible() && !md->isAnonymous())
              {
                Doxygen::indexList->addContentsItem(isDir,
                    md->qualifiedName(),md->getReference(),
                    md->getOutputFileBase(),md->anchor(),FALSE,addToIndex);
              }
              if (isDir)
              {
                Doxygen::indexList->incContentsDepth();
                for (const auto &emd : enumList)
                {
                  if (emd->isVisible())
                  {
                    Doxygen::indexList->addContentsItem(FALSE,
                        emd->qualifiedName(),emd->getReference(),emd->getOutputFileBase(),
                        emd->anchor(),FALSE,addToIndex);
                  }
                }
                Doxygen::indexList->decContentsDepth();
              }
            }
          }
        }
      }
      else if (lde->kind()==LayoutDocEntry::GroupClasses && addToIndex)
      {
        for (const auto &cd : gd->getClasses())
        {
          //bool nestedClassInSameGroup =
          //    cd->getOuterScope() && cd->getOuterScope()->definitionType()==Definition::TypeClass &&
          //    cd->getOuterScope()->partOfGroups().empty() && cd->getOuterScope()->partOfGroups()->contains(gd);
          //printf("===== GroupClasses: %s visible=%d nestedClassInSameGroup=%d\n",qPrint(cd->name()),cd->isVisible(),nestedClassInSameGroup);
          if (cd->isVisible() /*&& !nestedClassInSameGroup*/)
          {
            addMembersToIndex(cd,
                              LayoutDocManager::Class,
                              cd->displayName(),
                              cd->anchor(),
                              addToIndex,
                              TRUE);
          }
        }
      }
      else if (lde->kind()==LayoutDocEntry::GroupNamespaces && addToIndex && Config_getBool(SHOW_NAMESPACES))
      {
        for (const auto &nd : gd->getNamespaces())
        {
          if (nd->isVisible())
          {
            Doxygen::indexList->addContentsItem(FALSE,
                nd->displayName(),nd->getReference(),
                nd->getOutputFileBase(),QCString(),FALSE,Config_getBool(SHOW_NAMESPACES));
          }
        }
      }
      else if (lde->kind()==LayoutDocEntry::GroupConcepts && addToIndex)
      {
        for (const auto &cd : gd->getConcepts())
        {
          if (cd->isVisible())
          {
            Doxygen::indexList->addContentsItem(FALSE,
                cd->displayName(),cd->getReference(),
                cd->getOutputFileBase(),QCString(),FALSE,addToIndex);
          }
        }
      }
      else if (lde->kind()==LayoutDocEntry::GroupFiles && addToIndex)
      {
        for (const auto &fd : gd->getFiles())
        {
          if (fd->isVisible())
          {
            Doxygen::indexList->addContentsItem(FALSE,
                fd->displayName(),fd->getReference(),
                fd->getOutputFileBase(),QCString(),FALSE,fd->isLinkableViaGroup());
          }
        }
      }
      else if (lde->kind()==LayoutDocEntry::GroupDirs && addToIndex)
      {
        for (const auto &dd : gd->getDirs())
        {
          if (dd->isVisible())
          {
            Doxygen::indexList->addContentsItem(FALSE,
                dd->shortName(),dd->getReference(),
                dd->getOutputFileBase(),QCString(),FALSE,FALSE);
          }
        }
      }
      else if (lde->kind()==LayoutDocEntry::GroupPageDocs && addToIndex)
      {
        for (const auto &pd : gd->getPages())
        {
          const SectionInfo *si=nullptr;
          if (!pd->name().isEmpty()) si=SectionManager::instance().find(pd->name());
          hasSubPages = pd->hasSubPages();
          bool hasSections = pd->hasSections();
          Doxygen::indexList->addContentsItem(
              hasSubPages || hasSections,
              pd->title(),
              gd->getReference(),
              gd->getOutputFileBase(),
              si ? si->label() : QCString(),
              hasSubPages || hasSections,
              TRUE); // addToNavIndex
          if (hasSections || hasSubPages)
          {
            Doxygen::indexList->incContentsDepth();
          }
          if (hasSections)
          {
            pd->addSectionsToIndex();
          }
          writePages(pd,nullptr);
          if (hasSections || hasSubPages)
          {
            Doxygen::indexList->decContentsDepth();
          }
        }
      }
      else if (lde->kind()==LayoutDocEntry::GroupNestedGroups)
      {
        if (!gd->getSubGroups().empty())
        {
          startIndexHierarchy(ol,level+1);
          for (const auto &subgd : gd->getSubGroups())
          {
            writeGroupTreeNode(ol,subgd,level+1,ftv,addToIndex);
          }
          endIndexHierarchy(ol,level+1);
        }
      }
    }
 
    ol.endIndexListItem();
 
    if (addToIndex)
    {
      Doxygen::indexList->decContentsDepth();
    }
    if (ftv)
    {
      ftv->decContentsDepth();
    }
    //gd->visited=TRUE;
  }
}

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(), 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(), OutputList::parseText(), 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()

static void writeHierarchicalExceptionIndex ( OutputList & ol )

static

Definition at line 1331 of file index.cpp.

{
  if (Index::instance().numHierarchyExceptions()==0) return;
  ol.pushGeneratorState();
  //1.{
  ol.disable(OutputType::Man);
 
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ExceptionHierarchy);
  QCString title = lne ? lne->title() : theTranslator->trExceptionHierarchy();
  bool addToIndex = lne==nullptr || lne->visible();
 
  startFile(ol,"exceptionhierarchy",QCString(), title, HighlightedItem::ExceptionHierarchy);
  startTitle(ol,QCString());
  ol.parseText(title);
  endTitle(ol,QCString(),QCString());
  ol.startContents();
  ol.startTextBlock();
 
  if (Config_getBool(HAVE_DOT) && Config_getBool(GRAPHICAL_HIERARCHY))
  {
    ol.disable(OutputType::Latex);
    ol.disable(OutputType::RTF);
    ol.startParagraph();
    ol.startTextLink("exceptioninherits",QCString());
    ol.parseText(theTranslator->trGotoGraphicalHierarchy());
    ol.endTextLink();
    ol.endParagraph();
    ol.enable(OutputType::Latex);
    ol.enable(OutputType::RTF);
  }
  ol.parseText(lne ? lne->intro() : theTranslator->trExceptionHierarchyDescription());
  ol.endTextBlock();
 
  // ---------------
  // Static exception hierarchy for Latex/RTF
  // ---------------
  ol.pushGeneratorState();
  //2.{
  ol.disable(OutputType::Html);
  Doxygen::indexList->disable();
 
  writeClassHierarchy(ol,nullptr,addToIndex,ClassDef::Exception);
 
  Doxygen::indexList->enable();
  ol.popGeneratorState();
  //2.}
 
  // ---------------
  // Dynamic exception hierarchical index for HTML
  // ---------------
  ol.pushGeneratorState();
  //2.{
  ol.disableAllBut(OutputType::Html);
 
  {
    if (addToIndex)
    {
      Doxygen::indexList->addContentsItem(TRUE,title,QCString(),"exceptionhierarchy",QCString(),TRUE,TRUE);
    }
    FTVHelp ftv(false);
    writeClassHierarchy(ol,&ftv,addToIndex,ClassDef::Exception);
    TextStream t;
    ftv.generateTreeViewInline(t);
    ol.pushGeneratorState();
    ol.disableAllBut(OutputType::Html);
    ol.writeString(t.str().c_str());
    ol.popGeneratorState();
  }
  ol.popGeneratorState();
  //2.}
  // ------
 
  endFile(ol);
  ol.popGeneratorState();
  //1.}
}

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()

static void writeHierarchicalIndex ( OutputList & ol )

static

Definition at line 1119 of file index.cpp.

{
  if (Index::instance().numHierarchyClasses()==0) return;
  ol.pushGeneratorState();
  //1.{
  ol.disable(OutputType::Man);
  ol.disable(OutputType::Docbook);
 
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassHierarchy);
  QCString title = lne ? lne->title() : theTranslator->trClassHierarchy();
  bool addToIndex = lne==nullptr || lne->visible();
 
  startFile(ol,"hierarchy",QCString(), title, HighlightedItem::ClassHierarchy);
  startTitle(ol,QCString());
  ol.parseText(title);
  endTitle(ol,QCString(),QCString());
  ol.startContents();
  ol.startTextBlock();
 
  if (Config_getBool(HAVE_DOT) && Config_getBool(GRAPHICAL_HIERARCHY))
  {
  ol.pushGeneratorState();
    ol.disable(OutputType::Latex);
    ol.disable(OutputType::RTF);
    ol.disable(OutputType::Docbook);
    ol.startParagraph();
    ol.startTextLink("inherits",QCString());
    ol.parseText(theTranslator->trGotoGraphicalHierarchy());
    ol.endTextLink();
    ol.endParagraph();
  ol.popGeneratorState();
  }
  ol.parseText(lne ? lne->intro() : theTranslator->trClassHierarchyDescription());
  ol.endTextBlock();
 
  // ---------------
  // Static class hierarchy for Latex/RTF
  // ---------------
  ol.pushGeneratorState();
  //2.{
  ol.disable(OutputType::Html);
  Doxygen::indexList->disable();
 
  writeClassHierarchy(ol,nullptr,addToIndex,ClassDef::Class);
 
  Doxygen::indexList->enable();
  ol.popGeneratorState();
  //2.}
 
  // ---------------
  // Dynamic class hierarchical index for HTML
  // ---------------
  ol.pushGeneratorState();
  //2.{
  ol.disableAllBut(OutputType::Html);
 
  {
    if (addToIndex)
    {
      Doxygen::indexList->addContentsItem(TRUE,title,QCString(),"hierarchy",QCString(),TRUE,TRUE);
    }
    FTVHelp ftv(false);
    writeClassHierarchy(ol,&ftv,addToIndex,ClassDef::Class);
    TextStream t;
    ftv.generateTreeViewInline(t);
    ol.pushGeneratorState();
    ol.disableAllBut(OutputType::Html);
    ol.writeString(t.str().c_str());
    ol.popGeneratorState();
  }
  ol.popGeneratorState();
  //2.}
  // ------
 
  endFile(ol);
  ol.popGeneratorState();
  //1.}
}

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()

static void writeHierarchicalInterfaceIndex ( OutputList & ol )

static

Definition at line 1226 of file index.cpp.

{
  if (Index::instance().numHierarchyInterfaces()==0) return;
  ol.pushGeneratorState();
  //1.{
  ol.disable(OutputType::Man);
 
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::InterfaceHierarchy);
  QCString title = lne ? lne->title() : theTranslator->trInterfaceHierarchy();
  bool addToIndex = lne==nullptr || lne->visible();
 
  startFile(ol,"interfacehierarchy",QCString(), title, HighlightedItem::InterfaceHierarchy);
  startTitle(ol,QCString());
  ol.parseText(title);
  endTitle(ol,QCString(),QCString());
  ol.startContents();
  ol.startTextBlock();
 
  if (Config_getBool(HAVE_DOT) && Config_getBool(GRAPHICAL_HIERARCHY))
  {
    ol.disable(OutputType::Latex);
    ol.disable(OutputType::RTF);
    ol.startParagraph();
    ol.startTextLink("interfaceinherits",QCString());
    ol.parseText(theTranslator->trGotoGraphicalHierarchy());
    ol.endTextLink();
    ol.endParagraph();
    ol.enable(OutputType::Latex);
    ol.enable(OutputType::RTF);
  }
  ol.parseText(lne ? lne->intro() : theTranslator->trInterfaceHierarchyDescription());
  ol.endTextBlock();
 
  // ---------------
  // Static interface hierarchy for Latex/RTF
  // ---------------
  ol.pushGeneratorState();
  //2.{
  ol.disable(OutputType::Html);
  Doxygen::indexList->disable();
 
  writeClassHierarchy(ol,nullptr,addToIndex,ClassDef::Interface);
 
  Doxygen::indexList->enable();
  ol.popGeneratorState();
  //2.}
 
  // ---------------
  // Dynamic interface hierarchical index for HTML
  // ---------------
  ol.pushGeneratorState();
  //2.{
  ol.disableAllBut(OutputType::Html);
 
  {
    if (addToIndex)
    {
      Doxygen::indexList->addContentsItem(TRUE,title,QCString(),"interfacehierarchy",QCString(),TRUE,TRUE);
    }
    FTVHelp ftv(false);
    writeClassHierarchy(ol,&ftv,addToIndex,ClassDef::Interface);
    TextStream t;
    ftv.generateTreeViewInline(t);
    ol.pushGeneratorState();
    ol.disableAllBut(OutputType::Html);
    ol.writeString(t.str().c_str());
    ol.popGeneratorState();
  }
  ol.popGeneratorState();
  //2.}
  // ------
 
  endFile(ol);
  ol.popGeneratorState();
  //1.}
}

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()

static void writeIndex ( OutputList & ol )

static

Definition at line 4762 of file index.cpp.

{
  bool fortranOpt       = Config_getBool(OPTIMIZE_FOR_FORTRAN);
  bool vhdlOpt          = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
  bool disableIndex     = Config_getBool(DISABLE_INDEX);
  bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
  bool fullSidebar      = Config_getBool(FULL_SIDEBAR);
  QCString projectName  = Config_getString(PROJECT_NAME);
  // save old generator state
  ol.pushGeneratorState();
 
  QCString projPrefix;
  if (!projectName.isEmpty())
  {
    projPrefix=projectName+" ";
  }
 
  //--------------------------------------------------------------------
  // write HTML index
  //--------------------------------------------------------------------
  ol.disableAllBut(OutputType::Html);
 
  QCString defFileName =
    Doxygen::mainPage ? Doxygen::mainPage->docFile() : QCString("[generated]");
  int defLine =
    Doxygen::mainPage ? Doxygen::mainPage->docLine() : -1;
 
  QCString title;
  if (!mainPageHasTitle())
  {
    title = theTranslator->trMainPage();
  }
  else if (Doxygen::mainPage)
  {
    title = filterTitle(Doxygen::mainPage->title());
  }
 
  QCString indexName="index";
  ol.startFile(indexName,QCString(),title);
 
  if (Doxygen::mainPage)
  {
    bool hasSubs = Doxygen::mainPage->hasSubPages() || Doxygen::mainPage->hasSections();
    bool hasTitle = !projectName.isEmpty() && mainPageHasTitle() && qstricmp(title,projectName)!=0;
    //printf("** mainPage title=%s hasTitle=%d hasSubs=%d\n",qPrint(title),hasTitle,hasSubs);
    if (hasTitle) // to avoid duplicate entries in the treeview
    {
      Doxygen::indexList->addContentsItem(hasSubs,
                                          title,
                                          QCString(),
                                          indexName,
                                          QCString(),
                                          hasSubs,
                                          TRUE);
    }
    if (hasSubs)
    {
      writePages(Doxygen::mainPage.get(),nullptr);
    }
  }
 
  bool quickLinksAfterSplitbar = !disableIndex && generateTreeView && fullSidebar;
  ol.startQuickIndices();
  if (!disableIndex && !quickLinksAfterSplitbar)
  {
    ol.writeQuickLinks(HighlightedItem::Main,QCString());
  }
  ol.endQuickIndices();
  ol.writeSplitBar(indexName);
  if (quickLinksAfterSplitbar)
  {
    ol.writeQuickLinks(HighlightedItem::Main,QCString());
  }
  ol.writeSearchInfo();
  bool headerWritten=FALSE;
  if (Doxygen::mainPage)
  {
    if (!Doxygen::mainPage->title().isEmpty())
    {
      if (Doxygen::mainPage->title().lower() != "notitle")
        ol.startPageDoc(Doxygen::mainPage->title());
      else
        ol.startPageDoc("");
    }
    else
      ol.startPageDoc(projectName);
  }
  if (Doxygen::mainPage && !Doxygen::mainPage->title().isEmpty())
  {
    if (Doxygen::mainPage->title().lower()!="notitle")
    {
      ol.startHeaderSection();
      ol.startTitleHead(QCString());
      ol.generateDoc(Doxygen::mainPage->docFile(),Doxygen::mainPage->getStartBodyLine(),
                  Doxygen::mainPage.get(),nullptr,Doxygen::mainPage->title(),false,false,
                  QCString(),true,false,Config_getBool(MARKDOWN_SUPPORT));
      headerWritten = TRUE;
    }
  }
  else
  {
    if (!projectName.isEmpty())
    {
      ol.startHeaderSection();
      ol.startTitleHead(QCString());
      ol.parseText(theTranslator->trDocumentation(projectName));
      headerWritten = TRUE;
    }
  }
  if (headerWritten)
  {
    ol.endTitleHead(QCString(),QCString());
    ol.endHeaderSection();
  }
 
  ol.startContents();
  if (Config_getBool(DISABLE_INDEX) && Doxygen::mainPage==nullptr)
  {
    ol.writeQuickLinks(HighlightedItem::Main,QCString());
  }
 
  if (Doxygen::mainPage)
  {
    if (Doxygen::mainPage->localToc().isHtmlEnabled() && Doxygen::mainPage->hasSections())
    {
      Doxygen::mainPage->writeToc(ol,Doxygen::mainPage->localToc());
    }
 
    ol.startTextBlock();
    ol.generateDoc(defFileName,defLine,Doxygen::mainPage.get(),nullptr,
                Doxygen::mainPage->documentation(),true,false,
                QCString(),false,false,Config_getBool(MARKDOWN_SUPPORT));
    ol.endTextBlock();
    ol.endPageDoc();
  }
 
  QCString fn = Crawlmap::crawlFileName;
  addHtmlExtensionIfMissing(fn);
  ol.writeString("<a href=\"" + fn + "\"></a>\n");
  Doxygen::indexList->addIndexFile(fn);
 
  endFile(ol);
 
  ol.disable(OutputType::Html);
 
  //--------------------------------------------------------------------
  // write LaTeX/RTF index
  //--------------------------------------------------------------------
  ol.enable(OutputType::Latex);
  ol.enable(OutputType::Docbook);
  ol.enable(OutputType::RTF);
 
  if (Doxygen::mainPage)
  {
    msg("Generating main page...\n");
    Doxygen::mainPage->writeDocumentation(ol);
  }
 
  ol.startFile("refman",QCString(),QCString());
  ol.startIndexSection(IndexSection::isTitlePageStart);
  ol.disable(OutputType::Latex);
  ol.disable(OutputType::Docbook);
 
  if (projPrefix.isEmpty())
  {
    ol.parseText(theTranslator->trReferenceManual());
  }
  else
  {
    ol.parseText(projPrefix);
  }
 
  if (!Config_getString(PROJECT_NUMBER).isEmpty())
  {
    ol.startProjectNumber();
    ol.generateDoc(defFileName,defLine,Doxygen::mainPage.get(),nullptr,Config_getString(PROJECT_NUMBER),false,false,
                   QCString(),false,false,Config_getBool(MARKDOWN_SUPPORT));
    ol.endProjectNumber();
  }
  ol.endIndexSection(IndexSection::isTitlePageStart);
  ol.startIndexSection(IndexSection::isTitlePageAuthor);
  ol.parseText(theTranslator->trGeneratedBy());
  ol.endIndexSection(IndexSection::isTitlePageAuthor);
  ol.enable(OutputType::Latex);
  ol.enable(OutputType::Docbook);
 
  ol.lastIndexPage();
  if (Doxygen::mainPage)
  {
    ol.startIndexSection(IndexSection::isMainPage);
    ol.endIndexSection(IndexSection::isMainPage);
  }
  const auto &index = Index::instance();
  if (index.numDocumentedPages()>0)
  {
    ol.startIndexSection(IndexSection::isPageDocumentation);
    ol.endIndexSection(IndexSection::isPageDocumentation);
  }
 
  ol.disable(OutputType::Docbook);
  if (!Config_getBool(LATEX_HIDE_INDICES))
  {
    //if (indexedPages>0)
    //{
    //  ol.startIndexSection(isPageIndex);
    //  ol.parseText(/*projPrefix+*/ theTranslator->trPageIndex());
    //  ol.endIndexSection(isPageIndex);
    //}
    if (index.numDocumentedModules()>0)
    {
      ol.startIndexSection(IndexSection::isModuleIndex);
      ol.parseText(/*projPrefix+*/ theTranslator->trModuleIndex());
      ol.endIndexSection(IndexSection::isModuleIndex);
    }
    if (index.numDocumentedGroups()>0)
    {
      ol.startIndexSection(IndexSection::isTopicIndex);
      ol.parseText(/*projPrefix+*/ theTranslator->trTopicIndex());
      ol.endIndexSection(IndexSection::isTopicIndex);
    }
    if (Config_getBool(SHOW_NAMESPACES) && (index.numDocumentedNamespaces()>0))
    {
      LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Namespaces);
      if (lne)
      {
        ol.startIndexSection(IndexSection::isNamespaceIndex);
        ol.parseText(/*projPrefix+*/(fortranOpt?theTranslator->trModulesIndex():theTranslator->trNamespaceIndex()));
        ol.endIndexSection(IndexSection::isNamespaceIndex);
      }
    }
    if (index.numDocumentedConcepts()>0)
    {
      ol.startIndexSection(IndexSection::isConceptIndex);
      ol.parseText(/*projPrefix+*/theTranslator->trConceptIndex());
      ol.endIndexSection(IndexSection::isConceptIndex);
    }
    if (index.numHierarchyInterfaces()>0)
    {
      ol.startIndexSection(IndexSection::isClassHierarchyIndex);
      ol.parseText(/*projPrefix+*/theTranslator->trHierarchicalIndex());
      ol.endIndexSection(IndexSection::isClassHierarchyIndex);
    }
    if (index.numHierarchyClasses()>0)
    {
      LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassHierarchy);
      if (lne)
      {
        ol.startIndexSection(IndexSection::isClassHierarchyIndex);
        ol.parseText(/*projPrefix+*/
            (fortranOpt ? theTranslator->trCompoundIndexFortran() :
             vhdlOpt    ? theTranslator->trHierarchicalIndex()    :
                          theTranslator->trHierarchicalIndex()
            ));
        ol.endIndexSection(IndexSection::isClassHierarchyIndex);
      }
    }
    if (index.numHierarchyExceptions()>0)
    {
      ol.startIndexSection(IndexSection::isClassHierarchyIndex);
      ol.parseText(/*projPrefix+*/theTranslator->trHierarchicalIndex());
      ol.endIndexSection(IndexSection::isClassHierarchyIndex);
    }
    if (index.numAnnotatedInterfacesPrinted()>0)
    {
      ol.startIndexSection(IndexSection::isCompoundIndex);
      ol.parseText(/*projPrefix+*/theTranslator->trInterfaceIndex());
      ol.endIndexSection(IndexSection::isCompoundIndex);
    }
    if (index.numAnnotatedClassesPrinted()>0)
    {
      ol.startIndexSection(IndexSection::isCompoundIndex);
      ol.parseText(/*projPrefix+*/
          (fortranOpt ? theTranslator->trCompoundIndexFortran() :
              vhdlOpt ? theTranslator->trDesignUnitIndex()      :
                        theTranslator->trCompoundIndex()
          ));
      ol.endIndexSection(IndexSection::isCompoundIndex);
    }
    if (index.numAnnotatedStructsPrinted()>0)
    {
      ol.startIndexSection(IndexSection::isCompoundIndex);
      ol.parseText(/*projPrefix+*/theTranslator->trStructIndex());
      ol.endIndexSection(IndexSection::isCompoundIndex);
    }
    if (index.numAnnotatedExceptionsPrinted()>0)
    {
      ol.startIndexSection(IndexSection::isCompoundIndex);
      ol.parseText(/*projPrefix+*/theTranslator->trExceptionIndex());
      ol.endIndexSection(IndexSection::isCompoundIndex);
    }
    if (Config_getBool(SHOW_FILES) && index.numDocumentedFiles()>0)
    {
      ol.startIndexSection(IndexSection::isFileIndex);
      ol.parseText(/*projPrefix+*/theTranslator->trFileIndex());
      ol.endIndexSection(IndexSection::isFileIndex);
    }
  }
  ol.enable(OutputType::Docbook);
 
  if (index.numDocumentedModules()>0)
  {
    ol.startIndexSection(IndexSection::isModuleDocumentation);
    ol.parseText(/*projPrefix+*/theTranslator->trModuleDocumentation());
    ol.endIndexSection(IndexSection::isModuleDocumentation);
  }
  if (index.numDocumentedGroups()>0)
  {
    ol.startIndexSection(IndexSection::isTopicDocumentation);
    ol.parseText(/*projPrefix+*/theTranslator->trTopicDocumentation());
    ol.endIndexSection(IndexSection::isTopicDocumentation);
  }
  if (index.numDocumentedNamespaces()>0)
  {
    ol.startIndexSection(IndexSection::isNamespaceDocumentation);
    ol.parseText(/*projPrefix+*/(fortranOpt?theTranslator->trModuleDocumentation():theTranslator->trNamespaceDocumentation()));
    ol.endIndexSection(IndexSection::isNamespaceDocumentation);
  }
  if (index.numDocumentedConcepts()>0)
  {
    ol.startIndexSection(IndexSection::isConceptDocumentation);
    ol.parseText(/*projPrefix+*/theTranslator->trConceptDocumentation());
    ol.endIndexSection(IndexSection::isConceptDocumentation);
  }
  if (index.numAnnotatedInterfacesPrinted()>0)
  {
    ol.startIndexSection(IndexSection::isClassDocumentation);
    ol.parseText(/*projPrefix+*/theTranslator->trInterfaceDocumentation());
    ol.endIndexSection(IndexSection::isClassDocumentation);
  }
  if (index.numAnnotatedClassesPrinted()>0)
  {
    ol.startIndexSection(IndexSection::isClassDocumentation);
    ol.parseText(/*projPrefix+*/(fortranOpt?theTranslator->trTypeDocumentation():theTranslator->trClassDocumentation()));
    ol.endIndexSection(IndexSection::isClassDocumentation);
  }
  if (index.numAnnotatedStructsPrinted()>0)
  {
    ol.startIndexSection(IndexSection::isClassDocumentation);
    ol.parseText(/*projPrefix+*/theTranslator->trStructDocumentation());
    ol.endIndexSection(IndexSection::isClassDocumentation);
  }
  if (index.numAnnotatedExceptionsPrinted()>0)
  {
    ol.startIndexSection(IndexSection::isClassDocumentation);
    ol.parseText(/*projPrefix+*/theTranslator->trExceptionDocumentation());
    ol.endIndexSection(IndexSection::isClassDocumentation);
  }
  if (Config_getBool(SHOW_FILES) && index.numDocumentedFiles()>0)
  {
    ol.startIndexSection(IndexSection::isFileDocumentation);
    ol.parseText(/*projPrefix+*/theTranslator->trFileDocumentation());
    ol.endIndexSection(IndexSection::isFileDocumentation);
  }
  if (!Doxygen::exampleLinkedMap->empty())
  {
    ol.startIndexSection(IndexSection::isExampleDocumentation);
    ol.parseText(/*projPrefix+*/theTranslator->trExamples());
    ol.endIndexSection(IndexSection::isExampleDocumentation);
  }
  ol.endIndexSection(IndexSection::isEndIndex);
  endFile(ol);
 
  ol.popGeneratorState();
}

Referenced by writeIndexHierarchyEntries().

◆ writeIndexHierarchy()

void writeIndexHierarchy ( OutputList & ol )

Definition at line 5648 of file index.cpp.

{
  writeMenuData();
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry();
  if (lne)
  {
    writeIndexHierarchyEntries(ol,lne->children());
  }
}

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

Referenced by generateOutput().

◆ writeIndexHierarchyEntries()

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

static

Definition at line 5129 of file index.cpp.

{
  auto isRef = [](const QCString &s)
  {
    return s.startsWith("@ref") || s.startsWith("\\ref");
  };
  bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
  const auto &index = Index::instance();
  for (const auto &lne : entries)
  {
    LayoutNavEntry::Kind kind = lne->kind();
    size_t idx = static_cast<size_t>(kind);
    if (idx>=indexWritten.size())
    {
      size_t oldSize = indexWritten.size();
      size_t newSize = idx+1;
      indexWritten.resize(newSize);
      for (size_t i=oldSize; i<newSize; i++) indexWritten.at(i)=FALSE;
    }
    //printf("starting %s kind=%d\n",qPrint(lne->title()),lne->kind());
    bool addToIndex=lne->visible();
    bool needsClosing=FALSE;
    if (!indexWritten.at(idx))
    {
      switch(kind)
      {
        case LayoutNavEntry::MainPage:
          msg("Generating index page...\n");
          writeIndex(ol);
          break;
        case LayoutNavEntry::Pages:
          msg("Generating page index...\n");
          writePageIndex(ol);
          break;
        case LayoutNavEntry::Topics:
          msg("Generating topic index...\n");
          writeTopicIndex(ol);
          break;
        case LayoutNavEntry::Modules:
          {
            if (index.numDocumentedModules()>0 && addToIndex)
            {
              Doxygen::indexList->addContentsItem(TRUE,lne->title(),QCString(),lne->baseFile(),QCString());
              Doxygen::indexList->incContentsDepth();
              needsClosing=TRUE;
            }
          }
          break;
        case LayoutNavEntry::ModuleList:
          msg("Generating module index...\n");
          writeModuleIndex(ol);
          break;
        case LayoutNavEntry::ModuleMembers:
          msg("Generating module member index...\n");
          writeModuleMemberIndex(ol);
          break;
        case LayoutNavEntry::Namespaces:
          {
            bool showNamespaces = Config_getBool(SHOW_NAMESPACES);
            if (showNamespaces)
            {
              if (index.numDocumentedNamespaces()>0 && addToIndex)
              {
                Doxygen::indexList->addContentsItem(TRUE,lne->title(),QCString(),lne->baseFile(),QCString());
                Doxygen::indexList->incContentsDepth();
                needsClosing=TRUE;
              }
              if (LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Namespaces)!=lne.get()) // for backward compatibility with old layout file
              {
                msg("Generating namespace index...\n");
                writeNamespaceIndex(ol);
              }
            }
          }
          break;
        case LayoutNavEntry::NamespaceList:
          {
            bool showNamespaces = Config_getBool(SHOW_NAMESPACES);
            if (showNamespaces)
            {
              msg("Generating namespace index...\n");
              writeNamespaceIndex(ol);
            }
          }
          break;
        case LayoutNavEntry::NamespaceMembers:
          msg("Generating namespace member index...\n");
          writeNamespaceMemberIndex(ol);
          break;
        case LayoutNavEntry::Classes:
          if (index.numAnnotatedClasses()>0 && addToIndex)
          {
            Doxygen::indexList->addContentsItem(TRUE,lne->title(),QCString(),lne->baseFile(),QCString());
            Doxygen::indexList->incContentsDepth();
            needsClosing=TRUE;
          }
          if (LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Classes)!=lne.get()) // for backward compatibility with old layout file
          {
            msg("Generating annotated compound index...\n");
            writeAnnotatedIndex(ol);
          }
          break;
        case LayoutNavEntry::Concepts:
          msg("Generating concept index...\n");
          writeConceptIndex(ol);
          break;
        case LayoutNavEntry::ClassList:
          msg("Generating annotated compound index...\n");
          writeAnnotatedIndex(ol);
          break;
        case LayoutNavEntry::ClassIndex:
          msg("Generating alphabetical compound index...\n");
          writeAlphabeticalIndex(ol);
          break;
        case LayoutNavEntry::ClassHierarchy:
          msg("Generating hierarchical class index...\n");
          writeHierarchicalIndex(ol);
          if (Config_getBool(HAVE_DOT) && Config_getBool(GRAPHICAL_HIERARCHY))
          {
            msg("Generating graphical class hierarchy...\n");
            writeGraphicalClassHierarchy(ol);
          }
          break;
        case LayoutNavEntry::ClassMembers:
          if (!sliceOpt)
          {
            msg("Generating member index...\n");
            writeClassMemberIndex(ol);
          }
          break;
        case LayoutNavEntry::Interfaces:
          if (sliceOpt && index.numAnnotatedInterfaces()>0 && addToIndex)
          {
            Doxygen::indexList->addContentsItem(TRUE,lne->title(),QCString(),lne->baseFile(),QCString());
            Doxygen::indexList->incContentsDepth();
            needsClosing=TRUE;
          }
          break;
        case LayoutNavEntry::InterfaceList:
          if (sliceOpt)
          {
            msg("Generating annotated interface index...\n");
            writeAnnotatedInterfaceIndex(ol);
          }
          break;
        case LayoutNavEntry::InterfaceIndex:
          if (sliceOpt)
          {
            msg("Generating alphabetical interface index...\n");
            writeAlphabeticalInterfaceIndex(ol);
          }
          break;
        case LayoutNavEntry::InterfaceHierarchy:
          if (sliceOpt)
          {
            msg("Generating hierarchical interface index...\n");
            writeHierarchicalInterfaceIndex(ol);
            if (Config_getBool(HAVE_DOT) && Config_getBool(GRAPHICAL_HIERARCHY))
            {
              msg("Generating graphical interface hierarchy...\n");
              writeGraphicalInterfaceHierarchy(ol);
            }
          }
          break;
        case LayoutNavEntry::Structs:
          if (sliceOpt && index.numAnnotatedStructs()>0 && addToIndex)
          {
            Doxygen::indexList->addContentsItem(TRUE,lne->title(),QCString(),lne->baseFile(),QCString());
            Doxygen::indexList->incContentsDepth();
            needsClosing=TRUE;
          }
          break;
        case LayoutNavEntry::StructList:
          if (sliceOpt)
          {
            msg("Generating annotated struct index...\n");
            writeAnnotatedStructIndex(ol);
          }
          break;
        case LayoutNavEntry::StructIndex:
          if (sliceOpt)
          {
            msg("Generating alphabetical struct index...\n");
            writeAlphabeticalStructIndex(ol);
          }
          break;
        case LayoutNavEntry::Exceptions:
          if (sliceOpt && index.numAnnotatedExceptions()>0 && addToIndex)
          {
            Doxygen::indexList->addContentsItem(TRUE,lne->title(),QCString(),lne->baseFile(),QCString());
            Doxygen::indexList->incContentsDepth();
            needsClosing=TRUE;
          }
          break;
        case LayoutNavEntry::ExceptionList:
          if (sliceOpt)
          {
            msg("Generating annotated exception index...\n");
            writeAnnotatedExceptionIndex(ol);
          }
          break;
        case LayoutNavEntry::ExceptionIndex:
          if (sliceOpt)
          {
            msg("Generating alphabetical exception index...\n");
            writeAlphabeticalExceptionIndex(ol);
          }
          break;
        case LayoutNavEntry::ExceptionHierarchy:
          if (sliceOpt)
          {
            msg("Generating hierarchical exception index...\n");
            writeHierarchicalExceptionIndex(ol);
            if (Config_getBool(HAVE_DOT) && Config_getBool(GRAPHICAL_HIERARCHY))
            {
              msg("Generating graphical exception hierarchy...\n");
              writeGraphicalExceptionHierarchy(ol);
            }
          }
          break;
        case LayoutNavEntry::Files:
          {
            if (Config_getBool(SHOW_FILES) && index.numDocumentedFiles()>0 && addToIndex)
            {
              Doxygen::indexList->addContentsItem(TRUE,lne->title(),QCString(),lne->baseFile(),QCString());
              Doxygen::indexList->incContentsDepth();
              needsClosing=TRUE;
            }
            if (LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Files)!=lne.get()) // for backward compatibility with old layout file
            {
              msg("Generating file index...\n");
              writeFileIndex(ol);
            }
          }
          break;
        case LayoutNavEntry::FileList:
          msg("Generating file index...\n");
          writeFileIndex(ol);
          break;
        case LayoutNavEntry::FileGlobals:
          msg("Generating file member index...\n");
          writeFileMemberIndex(ol);
          break;
        case LayoutNavEntry::Examples:
          msg("Generating example index...\n");
          writeExampleIndex(ol);
          break;
        case LayoutNavEntry::User:
          if (addToIndex)
          {
            // prepend a ! or ^ marker to the URL to avoid tampering with it
            QCString url = correctURL(lne->url(),"!"); // add ! to relative URL
            bool isRelative=url.at(0)=='!';
            if (!url.isEmpty() && !isRelative) // absolute URL
            {
              url.prepend("^"); // prepend ^ to absolute URL
            }
            Doxygen::indexList->addContentsItem(TRUE,lne->title(),QCString(),
                                                url,QCString(),FALSE,isRef(lne->baseFile()) || isRelative);
          }
          break;
        case LayoutNavEntry::UserGroup:
          if (addToIndex)
          {
            QCString url = correctURL(lne->url(),"!"); // add ! to relative URL
            if (!url.isEmpty())
            {
              if (url=="!") // result of a "[none]" url
              {
                Doxygen::indexList->addContentsItem(TRUE,lne->title(),QCString(),QCString(),QCString(),FALSE,FALSE);
              }
              else
              {
                bool isRelative=url.at(0)=='!';
                if (!isRelative) // absolute URL
                {
                  url.prepend("^"); // prepend ^ to absolute URL
                }
                Doxygen::indexList->addContentsItem(TRUE,lne->title(),QCString(),
                                                    url,QCString(),FALSE,isRef(lne->baseFile()) || isRelative);
              }
            }
            else
            {
              Doxygen::indexList->addContentsItem(TRUE,lne->title(),QCString(),lne->baseFile(),QCString(),TRUE,TRUE);
            }
            Doxygen::indexList->incContentsDepth();
            needsClosing=TRUE;
          }
          writeUserGroupStubPage(ol,lne.get());
          break;
        case LayoutNavEntry::None:
          assert(kind != LayoutNavEntry::None); // should never happen, means not properly initialized
          break;
      }
      if (kind!=LayoutNavEntry::User && kind!=LayoutNavEntry::UserGroup) // User entry may appear multiple times
      {
        indexWritten.at(idx)=TRUE;
      }
    }
    writeIndexHierarchyEntries(ol,lne->children());
    if (needsClosing)
    {
      switch(kind)
      {
        case LayoutNavEntry::Modules:
        case LayoutNavEntry::Namespaces:
        case LayoutNavEntry::Classes:
        case LayoutNavEntry::Files:
        case LayoutNavEntry::UserGroup:
          Doxygen::indexList->decContentsDepth();
          break;
        default:
          break;
      }
    }
    //printf("ending %s kind=%d\n",qPrint(lne->title()),lne->kind());
  }
}

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(), 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()

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

static

Definition at line 2731 of file index.cpp.

{
  int index = static_cast<int>(type);
  const int numIndices = 4;
  ASSERT(index<numIndices);
 
  typedef void (*writeLinkForMember_t)(OutputList &ol,const MemberDef *md,const QCString &separator,
                                   QCString &prevNamespaceName);
 
  // each index tab has its own write function
  static writeLinkForMember_t writeLinkForMemberMap[numIndices] =
  {
    &writeClassLinkForMember,
    &writeFileLinkForMember,
    &writeNamespaceLinkForMember,
    &writeModuleLinkForMember
  };
  QCString prevName;
  QCString prevDefName;
  bool first=TRUE;
  bool firstSection=TRUE;
  bool firstItem=TRUE;
  const Index::MemberIndexList *mil = nullptr;
  std::string letter;
  for (const auto &kv : memberIndexMap)
  {
    if (!page.empty()) // specific page mode
    {
      auto it = memberIndexMap.find(page);
      if (it != memberIndexMap.end())
      {
        mil = &it->second;
        letter = page;
      }
    }
    else // do all pages
    {
      mil = &kv.second;
      letter = kv.first;
    }
    if (mil==nullptr || mil->empty()) continue;
    for (const auto &md : *mil)
    {
      const char *sep = nullptr;
      bool isFunc=!md->isObjCMethod() &&
        (md->isFunction() || md->isSlot() || md->isSignal());
      QCString name=type==Definition::TypeModule ? md->qualifiedName() : md->name();
      int startIndex = getPrefixIndex(name);
      if (name.data()+startIndex!=prevName) // new entry
      {
        if ((prevName.isEmpty() ||
            tolower(name.at(startIndex))!=tolower(prevName.at(0))) &&
            useSections) // new section
        {
          if (!firstItem)    ol.endItemListItem();
          if (!firstSection) ol.endItemList();
          QCString cs = letterToLabel(letter.c_str());
          QCString anchor=QCString("index_")+convertToId(cs);
          QCString title=QCString("- ")+letter.c_str()+" -";
          ol.startSection(anchor,title,SectionType::Subsection);
          ol.docify(title);
          ol.endSection(anchor,SectionType::Subsection);
          ol.startItemList();
          firstSection=FALSE;
          firstItem=TRUE;
        }
        else if (!useSections && first)
        {
          ol.startItemList();
          first=FALSE;
        }
 
        // member name
        if (!firstItem) ol.endItemListItem();
        ol.startItemListItem();
        firstItem=FALSE;
        ol.docify(name);
        if (isFunc) ol.docify("()");
        //ol.writeString("\n");
 
        // link to class
        prevDefName="";
        sep = "&#160;:&#160;";
        prevName = name.data()+startIndex;
      }
      else // same entry
      {
        sep = ", ";
        // link to class for other members with the same name
      }
      if (index<numIndices)
      {
        // write the link for the specific list type
        writeLinkForMemberMap[index](ol,md,sep,prevDefName);
      }
    }
    if (!page.empty())
    {
      break;
    }
  }
  if (!firstItem) ol.endItemListItem();
  ol.endItemList();
}

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()

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

static

Definition at line 463 of file index.cpp.

{
  bool isAnonymous = md->isAnonymous();
  bool hideUndocMembers = Config_getBool(HIDE_UNDOC_MEMBERS);
  const MemberVector &enumList = md->enumFieldList();
  bool isDir = !enumList.empty() && md->isEnumerate();
  auto defType = def->definitionType();
  bool namespaceMemberInFileDocs = md->getNamespaceDef() && defType==Definition::TypeFile;
  bool lAddToIndex = addToIndex && !namespaceMemberInFileDocs;
  QCString name = namespaceMemberInFileDocs || defType==Definition::TypeModule ?
                  md->qualifiedName() : md->name();
  if (md->getOuterScope()==def ||
      (md->getNamespaceDef()!=nullptr && defType==Definition::TypeFile) ||
      md->getOuterScope()==Doxygen::globalScope)
  {
    Doxygen::indexList->addContentsItem(isDir,
        name,md->getReference(),md->getOutputFileBase(),md->anchor(),FALSE,lAddToIndex && md->getGroupDef()==nullptr);
  }
  else // inherited member
  {
    Doxygen::indexList->addContentsItem(isDir,
        name,def->getReference(),def->getOutputFileBase(),md->anchor(),FALSE,lAddToIndex && md->getGroupDef()==nullptr);
  }
  if (isDir)
  {
    if (!isAnonymous)
    {
      Doxygen::indexList->incContentsDepth();
    }
    for (const auto &emd : enumList)
    {
      if (!hideUndocMembers || emd->hasDocumentation())
      {
        namespaceMemberInFileDocs = emd->getNamespaceDef() && defType==Definition::TypeFile;
        lAddToIndex = addToIndex && !namespaceMemberInFileDocs;
        QCString ename = namespaceMemberInFileDocs || defType==Definition::TypeModule ?
                         emd->qualifiedName() : emd->name();
        if (emd->getOuterScope()==def ||
            (emd->getNamespaceDef()!=nullptr && defType==Definition::TypeFile) ||
            emd->getOuterScope()==Doxygen::globalScope)
        {
          Doxygen::indexList->addContentsItem(FALSE,
              ename,emd->getReference(),emd->getOutputFileBase(),emd->anchor(),FALSE,lAddToIndex && emd->getGroupDef()==nullptr);
        }
        else // inherited member
        {
          Doxygen::indexList->addContentsItem(FALSE,
              ename,def->getReference(),def->getOutputFileBase(),emd->anchor(),FALSE,lAddToIndex && emd->getGroupDef()==nullptr);
        }
      }
    }
    if (!isAnonymous)
    {
      Doxygen::indexList->decContentsDepth();
    }
  }
}

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()

static void writeMenuData ( )

static

Definition at line 5632 of file index.cpp.

{
  if (!Config_getBool(GENERATE_HTML) || Config_getBool(DISABLE_INDEX)) return;
  QCString outputDir = Config_getBool(HTML_OUTPUT);
  LayoutNavEntry *root = LayoutDocManager::instance().rootNavEntry();
  std::ofstream t = Portable::openOutputStream(outputDir+"/menudata.js");
  if (t.is_open())
  {
    t << JAVASCRIPT_LICENSE_TEXT;
    t << "var menudata={";
    bool hasChildren = renderQuickLinksAsJs(t,root,TRUE);
    if (hasChildren) t << "]";
    t << "}\n";
  }
}

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

Referenced by writeIndexHierarchy().

◆ writeModuleIndex()

static void writeModuleIndex ( OutputList & ol )

static

Definition at line 4445 of file index.cpp.

{
  if (ModuleManager::instance().numDocumentedModules()==0) return;
  ol.pushGeneratorState();
  // 1.{
 
  ol.disable(OutputType::Man);
  ol.disable(OutputType::Docbook);
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ModuleList);
  if (lne==nullptr) lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Modules); // fall back
  QCString title = lne ? lne->title() : theTranslator->trModules();
  bool addToIndex = lne==nullptr || lne->visible();
 
  startFile(ol,"modules",QCString(),title,HighlightedItem::Modules);
  startTitle(ol,QCString());
  ol.parseText(title);
  endTitle(ol,QCString(),QCString());
  ol.startContents();
  ol.startTextBlock();
  ol.parseText(lne ? lne->intro() : theTranslator->trModulesListDescription(Config_getBool(EXTRACT_ALL)));
  ol.endTextBlock();
 
  // ---------------
  // Normal group index for Latex/RTF
  // ---------------
  // 2.{
  ol.pushGeneratorState();
  ol.disable(OutputType::Html);
  Doxygen::indexList->disable();
 
  writeModuleList(ol,nullptr,FALSE);
 
  Doxygen::indexList->enable();
  ol.popGeneratorState();
  // 2.}
 
  // ---------------
  // interactive group index for HTML
  // ---------------
  // 2.{
  ol.pushGeneratorState();
  ol.disableAllBut(OutputType::Html);
 
  {
    if (addToIndex)
    {
      Doxygen::indexList->addContentsItem(TRUE,title,QCString(),"modules",QCString(),TRUE,TRUE);
      Doxygen::indexList->incContentsDepth();
    }
    FTVHelp ftv(false);
    writeModuleList(ol,&ftv,addToIndex);
    TextStream t;
    ftv.generateTreeViewInline(t);
    ol.writeString(t.str().c_str());
    if (addToIndex)
    {
      Doxygen::indexList->decContentsDepth();
    }
  }
  ol.popGeneratorState();
  // 2.}
  endFile(ol);
  ol.popGeneratorState();
  // 1.}
}

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()

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

static

Definition at line 2716 of file index.cpp.

{
  const ModuleDef *mod=md->getModuleDef();
  if (mod && prevModuleName!=mod->displayName())
  {
    ol.writeString(separator);
    // link to the member declaration in the module page
    ol.writeObjectLink(mod->getReference(),mod->getOutputFileBase(),"r_"+md->anchor(),
        mod->displayName());
    prevModuleName = mod->displayName();
  }
}

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

Referenced by writeMemberList().

◆ writeModuleList()

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

static

Definition at line 4421 of file index.cpp.

{
  if (ftv)
  {
    ol.pushGeneratorState();
    ol.disable(OutputType::Html);
  }
  startIndexHierarchy(ol,0);
  for (const auto &mod : ModuleManager::instance().modules())
  {
    if (mod->isPrimaryInterface())
    {
      writeModuleTreeNode(ol,mod.get(),ftv,addToIndex);
    }
  }
  endIndexHierarchy(ol,0);
  if (ftv)
  {
    ol.popGeneratorState();
  }
}

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

Referenced by writeModuleIndex().

◆ writeModuleMemberIndex()

static void writeModuleMemberIndex ( OutputList & ol )

static

Definition at line 3747 of file index.cpp.

{
  const auto &index = Index::instance();
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ModuleMembers);
  bool addToIndex = lne==nullptr || lne->visible();
  if (index.numDocumentedModuleMembers(ModuleMemberHighlight::All)>0 && addToIndex)
  {
    Doxygen::indexList->addContentsItem(true,lne ? lne->title() : theTranslator->trModulesMembers(),QCString(),"modulemembers",QCString());
    Doxygen::indexList->incContentsDepth();
  }
  //bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
  writeModuleMemberIndexFiltered(ol,ModuleMemberHighlight::All);
  writeModuleMemberIndexFiltered(ol,ModuleMemberHighlight::Functions);
  writeModuleMemberIndexFiltered(ol,ModuleMemberHighlight::Variables);
  writeModuleMemberIndexFiltered(ol,ModuleMemberHighlight::Typedefs);
  writeModuleMemberIndexFiltered(ol,ModuleMemberHighlight::Enums);
  writeModuleMemberIndexFiltered(ol,ModuleMemberHighlight::EnumValues);
  if (index.numDocumentedModuleMembers(ModuleMemberHighlight::All)>0 && addToIndex)
  {
    Doxygen::indexList->decContentsDepth();
  }
}

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()

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

static

Definition at line 3627 of file index.cpp.

{
  const auto &index = Index::instance();
  if (index.numDocumentedModuleMembers(hl)==0) return;
 
  bool disableIndex     = Config_getBool(DISABLE_INDEX);
  bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
  bool fullSidebar      = Config_getBool(FULL_SIDEBAR);
  bool quickLinksAfterSplitbar = !disableIndex && generateTreeView && fullSidebar;
 
  bool multiPageIndex=FALSE;
  if (index.numDocumentedModuleMembers(hl)>MAX_ITEMS_BEFORE_MULTIPAGE_INDEX)
  {
    multiPageIndex=TRUE;
  }
 
  ol.pushGeneratorState();
  ol.disableAllBut(OutputType::Html);
 
  QCString extension=Doxygen::htmlFileExtension;
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ModuleMembers);
  QCString title = lne ? lne->title() : theTranslator->trModulesMembers();
  bool addToIndex = lne==nullptr || lne->visible();
 
  if (addToIndex)
  {
    Doxygen::indexList->addContentsItem(multiPageIndex,getMmhlInfo(hl)->title,QCString(),
        getMmhlInfo(hl)->fname,QCString(),multiPageIndex,TRUE);
    if (multiPageIndex) Doxygen::indexList->incContentsDepth();
  }
 
  bool first=TRUE;
  for (const auto &[letter,list] : index.isModuleIndexLetterUsed(hl))
  {
    QCString fileName = getMmhlInfo(hl)->fname;
    if (multiPageIndex)
    {
      QCString cs(letter);
      if (!first)
      {
        fileName+="_"+letterToLabel(cs);
      }
      if (addToIndex)
      {
        Doxygen::indexList->addContentsItem(FALSE,cs,QCString(),fileName,QCString(),FALSE,TRUE);
      }
    }
 
    bool quickIndex = index.numDocumentedModuleMembers(hl)>maxItemsBeforeQuickIndex;
 
    auto writeQuickLinks = [&,cap_letter=letter]()
    {
      ol.writeQuickLinks(HighlightedItem::ModuleMembers,QCString());
      if (!Config_getBool(HTML_DYNAMIC_MENUS))
      {
        startQuickIndexList(ol);
 
        // index item for all namespace member lists
        startQuickIndexItem(ol,
            getMmhlInfo(0)->fname+Doxygen::htmlFileExtension,hl==ModuleMemberHighlight::All,TRUE,first);
        ol.writeString(fixSpaces(getMmhlInfo(0)->title));
        endQuickIndexItem(ol);
 
        // index items per category member lists
        for (int i=1;i<ModuleMemberHighlight::Total;i++)
        {
          if (index.numDocumentedModuleMembers(static_cast<ModuleMemberHighlight::Enum>(i))>0)
          {
            startQuickIndexItem(ol,
                getMmhlInfo(i)->fname+Doxygen::htmlFileExtension,hl==i,TRUE,first);
            ol.writeString(fixSpaces(getMmhlInfo(i)->title));
            endQuickIndexItem(ol);
          }
        }
 
        endQuickIndexList(ol);
 
        if (quickIndex)
        {
          writeQuickMemberIndex(ol,index.isModuleIndexLetterUsed(hl),cap_letter,
              getMmhlInfo(hl)->fname,multiPageIndex);
        }
      }
    };
 
    ol.startFile(fileName+extension,QCString(),title);
    ol.startQuickIndices();
    if (!disableIndex && !quickLinksAfterSplitbar)
    {
      writeQuickLinks();
    }
    ol.endQuickIndices();
    ol.writeSplitBar(fileName);
    if (quickLinksAfterSplitbar)
    {
      writeQuickLinks();
    }
    ol.writeSearchInfo();
 
    ol.startContents();
 
    ol.startTextBlock();
    ol.parseText(hl == ModuleMemberHighlight::All && lne ? lne->intro() : theTranslator->trModuleMembersDescriptionTotal(hl));
    ol.endTextBlock();
 
    writeMemberList(ol,quickIndex,
        multiPageIndex ? letter : std::string(),
        index.isModuleIndexLetterUsed(hl),
        Definition::TypeModule);
    endFile(ol);
    first=FALSE;
  }
  if (multiPageIndex && addToIndex) Doxygen::indexList->decContentsDepth();
  ol.popGeneratorState();
}

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()

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

static

Definition at line 1783 of file index.cpp.

{
  for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Module))
  {
    if (lde->kind()==LayoutDocEntry::MemberDecl)
    {
      const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
      if (lmd)
      {
        MemberList *ml = mod->getMemberList(lmd->type);
        if (ml)
        {
          for (const auto &md : *ml)
          {
            //printf("  member %s visible=%d\n",qPrint(md->name()),md->visibleInIndex());
            if (md->visibleInIndex())
            {
              writeMemberToIndex(mod,md,addToIndex);
            }
          }
        }
      }
    }
  }
}

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

Referenced by writeModuleTreeNode().

◆ writeModuleTreeNode()

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

static

Definition at line 4374 of file index.cpp.

{
  int visibleMembers = mod->countVisibleMembers();
  bool isDir=visibleMembers>0;
  if (addToIndex)
  {
    Doxygen::indexList->addContentsItem(isDir,mod->name(),
                              mod->getReference(),mod->getOutputFileBase(),QCString(),isDir,TRUE);
  }
  if (ftv)
  {
    ftv->addContentsItem(false,mod->name(),
                         mod->getReference(),mod->getOutputFileBase(),QCString(),
                         false,false,mod);
  }
  ol.startIndexListItem();
  ol.startIndexItem(mod->getReference(),mod->getOutputFileBase());
  ol.parseText(mod->qualifiedName());
  ol.endIndexItem(mod->getReference(),mod->getOutputFileBase());
  if (mod->isReference())
  {
    ol.startTypewriter();
    ol.docify(" [external]");
    ol.endTypewriter();
  }
  if (addToIndex && isDir)
  {
     Doxygen::indexList->incContentsDepth();
  }
  if (isDir)
  {
    //ftv->incContentsDepth();
    writeClassTree(mod->getClasses(),nullptr,addToIndex,FALSE,ClassDef::Class);
    writeConceptList(mod->getConcepts(),nullptr,addToIndex);
    writeModuleMembers(mod,addToIndex);
    //ftv->decContentsDepth();
  }
  if (addToIndex && isDir)
  {
     Doxygen::indexList->decContentsDepth();
  }
  ol.endIndexListItem();
}

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()

static void writeNamespaceIndex ( OutputList & ol )

static

Definition at line 1991 of file index.cpp.

{
  if (Index::instance().numDocumentedNamespaces()==0) return;
  ol.pushGeneratorState();
  ol.disable(OutputType::Man);
  ol.disable(OutputType::Docbook);
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::NamespaceList);
  if (lne==nullptr) lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Namespaces); // fall back
  QCString title = lne ? lne->title() : theTranslator->trNamespaceList();
  bool addToIndex = lne==nullptr || lne->visible();
  startFile(ol,"namespaces",QCString(),title,HighlightedItem::Namespaces);
  startTitle(ol,QCString());
  ol.parseText(title);
  endTitle(ol,QCString(),QCString());
  ol.startContents();
  ol.startTextBlock();
  ol.parseText(lne ? lne->intro() : theTranslator->trNamespaceListDescription(Config_getBool(EXTRACT_ALL)));
  ol.endTextBlock();
 
  bool first=TRUE;
 
  // ---------------
  // Linear namespace index for Latex/RTF
  // ---------------
  ol.pushGeneratorState();
  ol.disable(OutputType::Html);
 
  for (const auto &nd : *Doxygen::namespaceLinkedMap)
  {
    if (nd->isLinkableInProject())
    {
      if (first)
      {
        ol.startIndexList();
        first=FALSE;
      }
      //ol.writeStartAnnoItem("namespace",nd->getOutputFileBase(),0,nd->name());
      ol.startIndexKey();
      if (nd->getLanguage()==SrcLangExt::VHDL)
      {
        ol.writeObjectLink(QCString(), nd->getOutputFileBase().replace(0,qstrlen("namespace"),"class"),QCString(),nd->displayName());
      }
      else
      {
        ol.writeObjectLink(QCString(),nd->getOutputFileBase(),QCString(),nd->displayName());
      }
      ol.endIndexKey();
 
      bool hasBrief = !nd->briefDescription().isEmpty();
      ol.startIndexValue(hasBrief);
      if (hasBrief)
      {
        //ol.docify(" (");
        ol.generateDoc(
                 nd->briefFile(),nd->briefLine(),
                 nd.get(),nullptr,
                 nd->briefDescription(TRUE),
                 FALSE, // index words
                 FALSE, // isExample
                 QCString(),     // example name
                 TRUE,  // single line
                 TRUE,  // link from index
                 Config_getBool(MARKDOWN_SUPPORT)
                );
        //ol.docify(")");
      }
      ol.endIndexValue(nd->getOutputFileBase(),hasBrief);
 
    }
  }
  if (!first) ol.endIndexList();
 
  ol.popGeneratorState();
 
  // ---------------
  // Hierarchical namespace index for HTML
  // ---------------
  ol.pushGeneratorState();
  ol.disableAllBut(OutputType::Html);
 
  {
    if (addToIndex)
    {
      Doxygen::indexList->addContentsItem(TRUE,title,QCString(),"namespaces",QCString(),TRUE,TRUE);
      Doxygen::indexList->incContentsDepth();
    }
    FTVHelp ftv(false);
    writeNamespaceTree(*Doxygen::namespaceLinkedMap,&ftv,TRUE,addToIndex);
    TextStream t;
    ftv.generateTreeViewInline(t);
    ol.writeString(t.str().c_str());
    if (addToIndex)
    {
      Doxygen::indexList->decContentsDepth();
    }
  }
 
  ol.popGeneratorState();
  // ------
 
  endFile(ol);
  ol.popGeneratorState();
}

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, VHDL, LayoutNavEntry::visible(), writeNamespaceTree(), OutputList::writeObjectLink(), and OutputList::writeString().

Referenced by writeIndexHierarchyEntries().

◆ writeNamespaceLinkForMember()

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

static

Definition at line 2703 of file index.cpp.

{
  const NamespaceDef *nd=md->getNamespaceDef();
  if (nd && prevNamespaceName!=nd->displayName())
  {
    ol.writeString(separator);
    ol.writeObjectLink(md->getReference(),md->getOutputFileBase(),md->anchor(),
        nd->displayName());
    prevNamespaceName = nd->displayName();
  }
}

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

Referenced by writeMemberList().

◆ writeNamespaceMemberIndex()

static void writeNamespaceMemberIndex ( OutputList & ol )

static

Definition at line 3575 of file index.cpp.

{
  const auto &index = Index::instance();
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::NamespaceMembers);
  bool addToIndex = lne==nullptr || lne->visible();
  if (index.numDocumentedNamespaceMembers(NamespaceMemberHighlight::All)>0 && addToIndex)
  {
    Doxygen::indexList->addContentsItem(true,lne ? lne->title() : theTranslator->trNamespaceMembers(),QCString(),"namespacemembers",QCString());
    Doxygen::indexList->incContentsDepth();
  }
  //bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
  writeNamespaceMemberIndexFiltered(ol,NamespaceMemberHighlight::All);
  writeNamespaceMemberIndexFiltered(ol,NamespaceMemberHighlight::Functions);
  writeNamespaceMemberIndexFiltered(ol,NamespaceMemberHighlight::Variables);
  writeNamespaceMemberIndexFiltered(ol,NamespaceMemberHighlight::Typedefs);
  writeNamespaceMemberIndexFiltered(ol,NamespaceMemberHighlight::Sequences);
  writeNamespaceMemberIndexFiltered(ol,NamespaceMemberHighlight::Dictionaries);
  writeNamespaceMemberIndexFiltered(ol,NamespaceMemberHighlight::Enums);
  writeNamespaceMemberIndexFiltered(ol,NamespaceMemberHighlight::EnumValues);
  if (index.numDocumentedNamespaceMembers(NamespaceMemberHighlight::All)>0 && addToIndex)
  {
    Doxygen::indexList->decContentsDepth();
  }
 
}

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()

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

static

Definition at line 3458 of file index.cpp.

{
  const auto &index = Index::instance();
  if (index.numDocumentedNamespaceMembers(hl)==0) return;
 
  bool disableIndex     = Config_getBool(DISABLE_INDEX);
  bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
  bool fullSidebar      = Config_getBool(FULL_SIDEBAR);
  bool quickLinksAfterSplitbar = !disableIndex && generateTreeView && fullSidebar;
 
  bool multiPageIndex=FALSE;
  if (index.numDocumentedNamespaceMembers(hl)>MAX_ITEMS_BEFORE_MULTIPAGE_INDEX)
  {
    multiPageIndex=TRUE;
  }
 
  ol.pushGeneratorState();
  ol.disableAllBut(OutputType::Html);
 
  QCString extension=Doxygen::htmlFileExtension;
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::NamespaceMembers);
  QCString title = lne ? lne->title() : theTranslator->trNamespaceMembers();
  bool addToIndex = lne==nullptr || lne->visible();
 
  if (addToIndex)
  {
    Doxygen::indexList->addContentsItem(multiPageIndex,getNmhlInfo(hl)->title,QCString(),
        getNmhlInfo(hl)->fname,QCString(),multiPageIndex,TRUE);
    if (multiPageIndex) Doxygen::indexList->incContentsDepth();
  }
 
  bool first=TRUE;
  for (const auto &[letter,list] : index.isNamespaceIndexLetterUsed(hl))
  {
    QCString fileName = getNmhlInfo(hl)->fname;
    if (multiPageIndex)
    {
      QCString cs(letter);
      if (!first)
      {
        fileName+="_"+letterToLabel(cs);
      }
      if (addToIndex)
      {
        Doxygen::indexList->addContentsItem(FALSE,cs,QCString(),fileName,QCString(),FALSE,TRUE);
      }
    }
 
    bool quickIndex = index.numDocumentedNamespaceMembers(hl)>maxItemsBeforeQuickIndex;
 
    auto writeQuickLinks = [&,cap_letter=letter]()
    {
      ol.writeQuickLinks(HighlightedItem::NamespaceMembers,QCString());
      if (!Config_getBool(HTML_DYNAMIC_MENUS))
      {
        startQuickIndexList(ol);
 
        // index item for all namespace member lists
        startQuickIndexItem(ol,
            getNmhlInfo(0)->fname+Doxygen::htmlFileExtension,hl==NamespaceMemberHighlight::All,TRUE,first);
        ol.writeString(fixSpaces(getNmhlInfo(0)->title));
        endQuickIndexItem(ol);
 
        // index items per category member lists
        for (int i=1;i<NamespaceMemberHighlight::Total;i++)
        {
          if (index.numDocumentedNamespaceMembers(static_cast<NamespaceMemberHighlight::Enum>(i))>0)
          {
            startQuickIndexItem(ol,
                getNmhlInfo(i)->fname+Doxygen::htmlFileExtension,hl==i,TRUE,first);
            ol.writeString(fixSpaces(getNmhlInfo(i)->title));
            endQuickIndexItem(ol);
          }
        }
 
        endQuickIndexList(ol);
 
        if (quickIndex)
        {
          writeQuickMemberIndex(ol,index.isNamespaceIndexLetterUsed(hl),cap_letter,
              getNmhlInfo(hl)->fname,multiPageIndex);
        }
      }
    };
 
    ol.startFile(fileName+extension,QCString(),title);
    ol.startQuickIndices();
    if (!disableIndex && !quickLinksAfterSplitbar)
    {
      writeQuickLinks();
    }
    ol.endQuickIndices();
    ol.writeSplitBar(fileName);
    if (quickLinksAfterSplitbar)
    {
      writeQuickLinks();
    }
    ol.writeSearchInfo();
 
    ol.startContents();
 
    ol.startTextBlock();
    ol.parseText(hl == NamespaceMemberHighlight::All && lne ? lne->intro() : theTranslator->trNamespaceMembersDescriptionTotal(hl));
    ol.endTextBlock();
 
    writeMemberList(ol,quickIndex,
        multiPageIndex ? letter : std::string(),
        index.isNamespaceIndexLetterUsed(hl),
        Definition::TypeNamespace);
    endFile(ol);
    first=FALSE;
  }
  if (multiPageIndex && addToIndex) Doxygen::indexList->decContentsDepth();
  ol.popGeneratorState();
}

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()

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

static

Definition at line 1757 of file index.cpp.

{
  for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Namespace))
  {
    if (lde->kind()==LayoutDocEntry::MemberDef)
    {
      const LayoutDocEntryMemberDef *lmd = dynamic_cast<const LayoutDocEntryMemberDef*>(lde.get());
      if (lmd)
      {
        MemberList *ml = nd->getMemberList(lmd->type);
        if (ml)
        {
          for (const auto &md : *ml)
          {
            //printf("  member %s visible=%d\n",qPrint(md->name()),md->visibleInIndex());
            if (md->visibleInIndex())
            {
              writeMemberToIndex(nd,md,addToIndex);
            }
          }
        }
      }
    }
  }
}

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

Referenced by writeNamespaceTreeElement().

◆ writeNamespaceTree() [1/2]

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

static

Definition at line 1886 of file index.cpp.

{
  for (const auto &nd : nsLinkedMap)
  {
    if (nd->isVisibleInHierarchy())
    {
      writeNamespaceTreeElement(nd.get(),ftv,rootOnly,addToIndex);
    }
  }
}

References writeNamespaceTreeElement().

◆ writeNamespaceTree() [2/2]

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

static

Definition at line 1874 of file index.cpp.

{
  for (const auto &nd : nsLinkedMap)
  {
    if (nd->isVisibleInHierarchy())
    {
      writeNamespaceTreeElement(nd,ftv,rootOnly,addToIndex);
    }
  }
}

References writeNamespaceTreeElement().

Referenced by writeNamespaceIndex(), and writeNamespaceTreeElement().

◆ writeNamespaceTreeElement()

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

static

Definition at line 1814 of file index.cpp.

{
  if (!nd->isAnonymous() &&
      (!rootOnly || nd->getOuterScope()==Doxygen::globalScope))
  {
 
    bool hasNestedNamespace = namespaceHasNestedNamespace(nd);
    bool hasChildren = hasNestedNamespace ||
      namespaceHasNestedClass(nd,false,ClassDef::Class) ||
      namespaceHasNestedConcept(nd);
    bool isLinkable  = nd->isLinkable();
    int visibleMembers = nd->countVisibleMembers();
 
    //printf("namespace %s hasChildren=%d visibleMembers=%d\n",qPrint(nd->name()),hasChildren,visibleMembers);
 
    QCString ref;
    QCString file;
    if (isLinkable)
    {
      ref  = nd->getReference();
      file = nd->getOutputFileBase();
      if (nd->getLanguage()==SrcLangExt::VHDL) // UGLY HACK
      {
        file=file.replace(0,qstrlen("namespace"),"class");
      }
    }
 
    bool isDir = hasChildren || visibleMembers>0;
    if (isLinkable || isDir)
    {
      ftv->addContentsItem(hasNestedNamespace,nd->localName(),ref,file,QCString(),FALSE,nd->partOfGroups().empty(),nd);
 
      if (addToIndex)
      {
        Doxygen::indexList->addContentsItem(isDir,nd->localName(),ref,file,QCString(),
            hasChildren && !file.isEmpty(),nd->partOfGroups().empty());
      }
      if (addToIndex && isDir)
      {
        Doxygen::indexList->incContentsDepth();
      }
 
      if (isDir)
      {
        ftv->incContentsDepth();
        writeNamespaceTree(nd->getNamespaces(),ftv,FALSE,addToIndex);
        writeClassTree(nd->getClasses(),nullptr,addToIndex,FALSE,ClassDef::Class);
        writeConceptList(nd->getConcepts(),nullptr,addToIndex);
        writeNamespaceMembers(nd,addToIndex);
        ftv->decContentsDepth();
      }
      if (addToIndex && isDir)
      {
        Doxygen::indexList->decContentsDepth();
      }
    }
  }
}

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(), VHDL, writeClassTree(), writeConceptList(), writeNamespaceMembers(), and writeNamespaceTree().

Referenced by writeNamespaceTree(), and writeNamespaceTree().

◆ writePageIndex()

static void writePageIndex ( OutputList & ol )

static

Definition at line 3926 of file index.cpp.

{
  if (Index::instance().numIndexedPages()==0) return;
  ol.pushGeneratorState();
  ol.disableAllBut(OutputType::Html);
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Pages);
  QCString title = lne ? lne->title() : theTranslator->trRelatedPages();
  startFile(ol,"pages",QCString(),title,HighlightedItem::Pages);
  startTitle(ol,QCString());
  ol.parseText(title);
  endTitle(ol,QCString(),QCString());
  ol.startContents();
  ol.startTextBlock();
  ol.parseText(lne ? lne->intro() : theTranslator->trRelatedPagesDescription());
  ol.endTextBlock();
 
  {
    FTVHelp ftv(false);
    for (const auto &pd : *Doxygen::pageLinkedMap)
    {
      if ((pd->getOuterScope()==nullptr ||
          pd->getOuterScope()->definitionType()!=Definition::TypePage) && // not a sub page
          pd->visibleInIndex()
         )
      {
        writePages(pd.get(),&ftv);
      }
    }
    TextStream t;
    ftv.generateTreeViewInline(t);
    ol.writeString(t.str().c_str());
  }
 
//  ol.popGeneratorState();
  // ------
 
  endFile(ol);
  ol.popGeneratorState();
}

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()

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

static

Definition at line 3866 of file index.cpp.

{
  //printf("writePages()=%s pd=%p mainpage=%p\n",qPrint(pd->name()),(void*)pd,(void*)Doxygen::mainPage.get());
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Pages);
  bool addToIndex = lne==nullptr || lne->visible();
  if (!addToIndex) return;
 
  bool hasSubPages = pd->hasSubPages();
  bool hasSections = pd->hasSections();
 
  if (pd->visibleInIndex())
  {
    QCString pageTitle;
 
    if (pd->title().isEmpty())
      pageTitle=pd->name();
    else
      pageTitle=filterTitle(pd->title());
 
    if (ftv)
    {
      //printf("*** adding %s hasSubPages=%d hasSections=%d\n",qPrint(pageTitle),hasSubPages,hasSections);
      ftv->addContentsItem(
          hasSubPages,pageTitle,
          pd->getReference(),pd->getOutputFileBase(),
          QCString(),hasSubPages,TRUE,pd);
    }
    if (addToIndex && pd!=Doxygen::mainPage.get())
    {
      Doxygen::indexList->addContentsItem(
          hasSubPages || hasSections,pageTitle,
          pd->getReference(),pd->getOutputFileBase(),
          QCString(),hasSubPages,TRUE,pd);
    }
  }
  if (hasSubPages && ftv) ftv->incContentsDepth();
  bool doIndent = (hasSections || hasSubPages) &&
                  (pd!=Doxygen::mainPage.get() || mainPageHasOwnTitle());
  if (doIndent)
  {
    Doxygen::indexList->incContentsDepth();
  }
  if (hasSections)
  {
    pd->addSectionsToIndex();
  }
  for (const auto &subPage : pd->getSubPages())
  {
    writePages(subPage,ftv);
  }
  if (hasSubPages && ftv) ftv->decContentsDepth();
  if (doIndent)
  {
    Doxygen::indexList->decContentsDepth();
  }
  //printf("end writePages()=%s\n",qPrint(pd->title()));
}

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

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

◆ writeQuickMemberIndex()

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

static

Definition at line 3044 of file index.cpp.

{
  bool first=TRUE;
  startQuickIndexList(ol,TRUE);
  for (const auto &[letter,list] : map)
  {
    QCString ci(letter);
    QCString is = letterToLabel(ci);
    QCString anchor;
    QCString extension=Doxygen::htmlFileExtension;
    if (!multiPage)
      anchor="#index_";
    else if (first)
      anchor=fullName+extension+"#index_";
    else
      anchor=fullName+"_"+is+extension+"#index_";
    startQuickIndexItem(ol,anchor+convertToId(is),letter==page,TRUE,first);
    ol.writeString(ci);
    endQuickIndexItem(ol);
    first=FALSE;
  }
  endQuickIndexList(ol);
}

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

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

◆ writeSingleFileIndex()

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

static

Definition at line 1458 of file index.cpp.

{
  //printf("Found filedef %s\n",qPrint(fd->name()));
  bool doc = fd->isLinkableInProject();
  bool src = fd->generateSourceFile();
  bool nameOk = !fd->isDocumentationFile();
  if (nameOk && (doc || src) && !fd->isReference())
  {
    QCString path;
    if (Config_getBool(FULL_PATH_NAMES))
    {
      path=stripFromPath(fd->getPath());
    }
    QCString fullName=fd->name();
    if (!path.isEmpty())
    {
      if (path.at(path.length()-1)!='/') fullName.prepend("/");
      fullName.prepend(path);
    }
 
    ol.startIndexKey();
    ol.docify(path);
    if (doc)
    {
      ol.writeObjectLink(QCString(),fd->getOutputFileBase(),QCString(),fd->name());
      //if (addToIndex)
      //{
      //  addMembersToIndex(fd,LayoutDocManager::File,fullName,QCString());
      //}
    }
    else if (src)
    {
      ol.writeObjectLink(QCString(),fd->getSourceFileBase(),QCString(),fd->name());
    }
    if (doc && src)
    {
      ol.pushGeneratorState();
      ol.disableAllBut(OutputType::Html);
      ol.docify(" ");
      ol.startTextLink(fd->includeName(),QCString());
      ol.docify("[");
      ol.parseText(theTranslator->trCode());
      ol.docify("]");
      ol.endTextLink();
      ol.popGeneratorState();
    }
    ol.endIndexKey();
    bool hasBrief = !fd->briefDescription().isEmpty();
    ol.startIndexValue(hasBrief);
    if (hasBrief)
    {
      //ol.docify(" (");
      ol.generateDoc(
          fd->briefFile(),fd->briefLine(),
          fd,nullptr,
          fd->briefDescription(TRUE),
          FALSE, // index words
          FALSE, // isExample
          QCString(), // example name
          TRUE,  // single line
          TRUE,  // link from index
          Config_getBool(MARKDOWN_SUPPORT)
          );
      //ol.docify(")");
    }
    if (doc)
    {
      ol.endIndexValue(fd->getOutputFileBase(),hasBrief);
    }
    else // src
    {
      ol.endIndexValue(fd->getSourceFileBase(),hasBrief);
    }
    //ol.popGeneratorState();
    // --------------------------------------------------------
  }
}

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()

static void writeTopicIndex ( OutputList & ol )

static

Definition at line 4305 of file index.cpp.

{
  if (Index::instance().numDocumentedGroups()==0) return;
  ol.pushGeneratorState();
  // 1.{
  ol.disable(OutputType::Man);
  ol.disable(OutputType::Docbook);
  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Topics);
  QCString title = lne ? lne->title() : theTranslator->trTopics();
  bool addToIndex = lne==nullptr || lne->visible();
 
  startFile(ol,"topics",QCString(),title,HighlightedItem::Topics);
  startTitle(ol,QCString());
  ol.parseText(title);
  endTitle(ol,QCString(),QCString());
  ol.startContents();
  ol.startTextBlock();
  ol.parseText(lne ? lne->intro() : theTranslator->trTopicListDescription());
  ol.endTextBlock();
 
  // ---------------
  // Normal group index for Latex/RTF
  // ---------------
  // 2.{
  ol.pushGeneratorState();
  ol.disable(OutputType::Html);
  Doxygen::indexList->disable();
 
  writeGroupHierarchy(ol,nullptr,FALSE);
 
  Doxygen::indexList->enable();
  ol.popGeneratorState();
  // 2.}
 
  // ---------------
  // interactive group index for HTML
  // ---------------
  // 2.{
  ol.pushGeneratorState();
  ol.disableAllBut(OutputType::Html);
 
  {
    if (addToIndex)
    {
      Doxygen::indexList->addContentsItem(TRUE,title,QCString(),"topics",QCString(),TRUE,TRUE);
      Doxygen::indexList->incContentsDepth();
    }
    FTVHelp ftv(false);
    writeGroupHierarchy(ol,&ftv,addToIndex);
    TextStream t;
    ftv.generateTreeViewInline(t);
    ol.disableAllBut(OutputType::Html);
    ol.writeString(t.str().c_str());
    if (addToIndex)
    {
      Doxygen::indexList->decContentsDepth();
    }
  }
  ol.popGeneratorState();
  // 2.}
 
  endFile(ol);
  ol.popGeneratorState();
  // 1.}
}

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()

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

static

Definition at line 4725 of file index.cpp.

{
  if (lne->baseFile().startsWith("usergroup"))
  {
    ol.pushGeneratorState();
    ol.disableAllBut(OutputType::Html);
    startFile(ol,lne->baseFile(),QCString(),lne->title(),HighlightedItem::UserGroup);
    startTitle(ol,QCString());
    ol.parseText(lne->title());
    endTitle(ol,QCString(),QCString());
    ol.startContents();
    int count=0;
    for (const auto &entry: lne->children())
    {
      if (entry->visible()) count++;
    }
    if (count>0)
    {
      ol.writeString("<ul>\n");
      for (const auto &entry: lne->children())
      {
        if (entry->visible())
        {
          ol.writeString("<li><a href=\""+entry->url()+"\"><span>"+
              fixSpaces(entry->title())+"</span></a></li>\n");
        }
      }
      ol.writeString("</ul>\n");
    }
    endFile(ol);
    ol.popGeneratorState();
  }
}

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 5127 of file index.cpp.

Referenced by writeIndexHierarchyEntries().

◆ maxItemsBeforeQuickIndex

const int maxItemsBeforeQuickIndex = MAX_ITEMS_BEFORE_QUICK_INDEX

Definition at line 341 of file index.cpp.

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

Classes

Macros

Typedefs

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ MAX_ITEMS_BEFORE_MULTIPAGE_INDEX

◆ MAX_ITEMS_BEFORE_QUICK_INDEX

Typedef Documentation

◆ UsedIndexLetters

Function Documentation

◆ addMembersToIndex()

◆ countAnnotatedClasses()

◆ countClassesInTreeList()

◆ countClassHierarchy()

◆ countConcepts()

◆ countDirs()

◆ countFiles()

◆ countGroups()

◆ countNamespaces()

◆ countRelatedPages()

◆ dirHasVisibleChildren()

◆ endFile()

◆ endFileWithNavPath()

◆ endIndexHierarchy()

◆ endQuickIndexItem()

◆ endQuickIndexList()

◆ endTitle()

◆ get_pointer() [1/3]

◆ get_pointer() [2/3]

◆ get_pointer() [3/3]

◆ getCmhlInfo()

◆ getFmhlInfo()

◆ getMmhlInfo()

◆ getNmhlInfo()

◆ isId1()

◆ letterToLabel()

◆ mainPageHasOwnTitle()

◆ MemberIndexMap_add()

◆ quickLinkVisible()

◆ renderMemberIndicesAsJs()

◆ renderQuickLinksAsJs()

◆ startFile()

◆ startIndexHierarchy()

◆ startQuickIndexItem()

◆ startQuickIndexList()

◆ startTitle()

◆ writeAlphabeticalClassList()

◆ writeAlphabeticalExceptionIndex()

◆ writeAlphabeticalIndex()

◆ writeAlphabeticalInterfaceIndex()

◆ writeAlphabeticalStructIndex()

◆ writeAnnotatedClassList()

◆ writeAnnotatedExceptionIndex()

◆ writeAnnotatedIndex()

◆ writeAnnotatedIndexGeneric()

◆ writeAnnotatedInterfaceIndex()

◆ writeAnnotatedStructIndex()

◆ writeClassHierarchy()

◆ writeClassLinkForMember()

◆ writeClassMemberIndex()

◆ writeClassMemberIndexFiltered()

◆ writeClassTree()

◆ writeClassTreeForList()

◆ writeClassTreeInsideNamespace() [1/2]

◆ writeClassTreeInsideNamespace() [2/2]

◆ writeClassTreeInsideNamespaceElement()

◆ writeClassTreeToOutput()

◆ writeConceptIndex()

◆ writeConceptList()

◆ writeConceptRootList()

◆ writeConceptTreeInsideNamespace()

◆ writeConceptTreeInsideNamespaceElement()

◆ writeDirHierarchy()

◆ writeDirTreeNode()

◆ writeExampleIndex()

◆ writeFileIndex()

◆ writeFileLinkForMember()

◆ writeFileMemberIndex()