My Project
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Classes | Macros | Functions | Variables
index.cpp File Reference

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

#include <stdlib.h>
#include <qtextstream.h>
#include <qdatetime.h>
#include <qdir.h>
#include <qregexp.h>
#include "message.h"
#include "index.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 "pagedef.h"
#include "dirdef.h"
#include "vhdldocgen.h"
#include "layout.h"
#include "memberlist.h"
#include "classlist.h"
#include "namespacedef.h"
#include "filename.h"

Go to the source code of this file.

Classes

class  MemberIndexList
 
class  PrefixIgnoreClassList
 
class  AlphaIndexTableCell
 
class  AlphaIndexTableRows
 
class  AlphaIndexTableRowsIterator
 
class  AlphaIndexTableColumns
 
class  UsedIndexLetters
 
struct  CmhlInfo
 
struct  FmhlInfo
 
struct  NmhlInfo
 

Macros

#define MAX_ITEMS_BEFORE_MULTIPAGE_INDEX   200
 
#define MAX_ITEMS_BEFORE_QUICK_INDEX   30
 
#define NEXT_ROW()
 

Functions

static int countClassHierarchy ()
 
static void countFiles (int &htmlFiles, int &files)
 
static int countGroups ()
 
static int countDirs ()
 
static int countNamespaces ()
 
static int countAnnotatedClasses (int *cp)
 
static void countRelatedPages (int &docPages, int &indexPages)
 
void countDataStructures ()
 
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 char *l, bool hl, bool compact, bool &first)
 
static void endQuickIndexItem (OutputList &ol)
 
QCString fixSpaces (const QCString &s)
 
void startTitle (OutputList &ol, const char *fileName, Definition *def)
 
void endTitle (OutputList &ol, const char *fileName, const char *name)
 
void startFile (OutputList &ol, const char *name, const char *manName, const char *title, HighlightedItem hli, bool additionalIndices, const char *altSidebarName)
 
void endFile (OutputList &ol, bool skipNavIndex, bool skipEndContents, const QCString &navPath)
 
void endFileWithNavPath (Definition *d, OutputList &ol)
 
template<class T >
void addMembersToIndex (T *def, LayoutDocManager::LayoutPart part, const QCString &name, const QCString &anchor, bool addToIndex=TRUE, bool preventSeparateIndex=FALSE)
 
static void writeClassTree (OutputList &ol, const BaseClassList *bcl, bool hideSuper, int level, FTVHelp *ftv, bool addToIndex)
 
static bool dirHasVisibleChildren (DirDef *dd)
 
static void writeDirTreeNode (OutputList &ol, DirDef *dd, int level, FTVHelp *ftv, bool addToIndex)
 
static void writeDirHierarchy (OutputList &ol, FTVHelp *ftv, bool addToIndex)
 
static void writeClassTreeForList (OutputList &ol, ClassSDict *cl, bool &started, FTVHelp *ftv, bool addToIndex)
 
static void writeClassHierarchy (OutputList &ol, FTVHelp *ftv, bool addToIndex)
 
static int countClassesInTreeList (const ClassSDict &cl)
 
static void writeHierarchicalIndex (OutputList &ol)
 
static void writeGraphicalClassHierarchy (OutputList &ol)
 
static void writeSingleFileIndex (OutputList &ol, FileDef *fd)
 
static void writeFileIndex (OutputList &ol)
 
void writeClassTree (ClassSDict *clDict, FTVHelp *ftv, bool addToIndex, bool globalOnly)
 
static void writeNamespaceTree (NamespaceSDict *nsDict, FTVHelp *ftv, bool rootOnly, bool showClasses, bool addToIndex)
 
static void writeNamespaceIndex (OutputList &ol)
 
static void writeAnnotatedClassList (OutputList &ol)
 
static QCString letterToLabel (uint startLetter)
 
static void writeAlphabeticalClassList (OutputList &ol)
 
static void writeAlphabeticalIndex (OutputList &ol)
 
static void writeAnnotatedIndex (OutputList &ol)
 
static void writeClassLinkForMember (OutputList &ol, MemberDef *md, const char *separator, QCString &prevClassName)
 
static void writeFileLinkForMember (OutputList &ol, MemberDef *md, const char *separator, QCString &prevFileName)
 
static void writeNamespaceLinkForMember (OutputList &ol, MemberDef *md, const char *separator, QCString &prevNamespaceName)
 
static void writeMemberList (OutputList &ol, bool useSections, int page, const LetterToIndexMap< MemberIndexList > &memberLists, DefinitionIntf::DefType type)
 
void initClassMemberIndices ()
 
void addClassMemberNameToIndex (MemberDef *md)
 
void initNamespaceMemberIndices ()
 
void addNamespaceMemberNameToIndex (MemberDef *md)
 
void initFileMemberIndices ()
 
void addFileMemberNameToIndex (MemberDef *md)
 
static void writeQuickMemberIndex (OutputList &ol, const LetterToIndexMap< MemberIndexList > &charUsed, uint page, QCString fullName, bool multiPage)
 
static const CmhlInfo * getCmhlInfo (int hl)
 
static void writeClassMemberIndexFiltered (OutputList &ol, ClassMemberHighlight hl)
 
static void writeClassMemberIndex (OutputList &ol)
 
static const FmhlInfo * getFmhlInfo (int hl)
 
static void writeFileMemberIndexFiltered (OutputList &ol, FileMemberHighlight hl)
 
static void writeFileMemberIndex (OutputList &ol)
 
static const NmhlInfo * getNmhlInfo (int hl)
 
static void writeNamespaceMemberIndexFiltered (OutputList &ol, NamespaceMemberHighlight hl)
 
static void writeNamespaceMemberIndex (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, GroupDef *gd, int level, FTVHelp *ftv, bool addToIndex)
 
static void writeGroupHierarchy (OutputList &ol, FTVHelp *ftv, bool addToIndex)
 
static void writeGroupIndex (OutputList &ol)
 
static void writeUserGroupStubPage (OutputList &ol, LayoutNavEntry *lne)
 
static void writeIndex (OutputList &ol)
 
static void writeIndexHierarchyEntries (OutputList &ol, const QList< LayoutNavEntry > &entries)
 
static bool quickLinkVisible (LayoutNavEntry::Kind kind)
 
template<class T >
void renderMemberIndicesAsJs (FTextStream &t, int total, const int *numDocumented, const LetterToIndexMap< MemberIndexList > *memberLists, const T *(*getInfo)(int hl))
 
static bool renderQuickLinksAsJs (FTextStream &t, LayoutNavEntry *root, bool first)
 
static void writeMenuData ()
 
void writeIndexHierarchy (OutputList &ol)
 

Variables

int annotatedClasses
 
int annotatedClassesPrinted
 
int hierarchyClasses
 
int documentedFiles
 
int documentedGroups
 
int documentedNamespaces
 
int indexedPages
 
int documentedClassMembers [CMHL_Total]
 
int documentedFileMembers [FMHL_Total]
 
int documentedNamespaceMembers [NMHL_Total]
 
int documentedHtmlFiles
 
int documentedPages
 
int documentedDirs
 
static LetterToIndexMap
< MemberIndexList > 		g_memberIndexLetterUsed [CMHL_Total]
 
static LetterToIndexMap
< MemberIndexList > 		g_fileIndexLetterUsed [FMHL_Total]
 
static LetterToIndexMap
< MemberIndexList > 		g_namespaceIndexLetterUsed [NMHL_Total]
 
const int maxItemsBeforeQuickIndex = MAX_ITEMS_BEFORE_QUICK_INDEX
 
static QArray< bool > indexWritten
 

Detailed Description

This file contains functions for the various index pages.

Definition in file index.cpp.

Macro Definition Documentation

#define MAX_ITEMS_BEFORE_MULTIPAGE_INDEX   200

Definition at line 51 of file index.cpp.

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

#define MAX_ITEMS_BEFORE_QUICK_INDEX   30

Definition at line 52 of file index.cpp.

#define NEXT_ROW ( )
Value:
do \
{ \
if (row>maxRows) maxRows=row; \
if (row>=rows && col<columns) \
{ \
col++; \
row=0; \
tableRows = new AlphaIndexTableRows; \
tableColumns.append(tableRows); \
} \
} \
while(0) \

Referenced by writeAlphabeticalClassList().

Function Documentation

void addClassMemberNameToIndex ( MemberDef *  md)

Definition at line 2265 of file index.cpp.

References LetterToIndexMap< T >::append(), CMHL_All, CMHL_Enums, CMHL_EnumValues, CMHL_Events, CMHL_Functions, CMHL_Properties, CMHL_Related, CMHL_Typedefs, CMHL_Variables, Config_getBool, documentedClassMembers, MemberDef::getClassDef(), MemberDef::getEnumScope(), getPrefixIndex(), getUtf8CodeToLower(), MemberDef::isEnumerate(), MemberDef::isEnumValue(), MemberDef::isEvent(), MemberDef::isForeign(), MemberDef::isFriend(), MemberDef::isFunction(), ClassDef::isLinkableInProject(), MemberDef::isLinkableInProject(), MemberDef::isProperty(), MemberDef::isRelated(), MemberDef::isSignal(), MemberDef::isSlot(), MemberDef::isStrong(), MemberDef::isTypedef(), MemberDef::isVariable(), Definition::name(), ClassDef::templateMaster(), and MemberDef::typeString().

Referenced by addMembersToIndex().

{
static bool hideFriendCompounds = Config_getBool(HIDE_FRIEND_COMPOUNDS);
ClassDef *cd=0;
if (md->isLinkableInProject() &&
(cd=md->getClassDef()) &&
cd->isLinkableInProject() &&
cd->templateMaster()==0)
{
QCString n = md->name();
int index = getPrefixIndex(n);
uint letter = getUtf8CodeToLower(n,index);
if (!n.isEmpty())
{
bool isFriendToHide = hideFriendCompounds &&
(QCString(md->typeString())=="friend class" ||
QCString(md->typeString())=="friend struct" ||
QCString(md->typeString())=="friend union");
if (!(md->isFriend() && isFriendToHide) &&
(!md->isEnumValue() || (md->getEnumScope() && !md->getEnumScope()->isStrong()))
)
{
g_memberIndexLetterUsed[CMHL_All].append(letter,md);
documentedClassMembers[CMHL_All]++;
}
if (md->isFunction() || md->isSlot() || md->isSignal())
{
g_memberIndexLetterUsed[CMHL_Functions].append(letter,md);
documentedClassMembers[CMHL_Functions]++;
}
else if (md->isVariable())
{
g_memberIndexLetterUsed[CMHL_Variables].append(letter,md);
documentedClassMembers[CMHL_Variables]++;
}
else if (md->isTypedef())
{
g_memberIndexLetterUsed[CMHL_Typedefs].append(letter,md);
documentedClassMembers[CMHL_Typedefs]++;
}
else if (md->isEnumerate())
{
g_memberIndexLetterUsed[CMHL_Enums].append(letter,md);
documentedClassMembers[CMHL_Enums]++;
}
else if (md->isEnumValue() && md->getEnumScope() && !md->getEnumScope()->isStrong())
{
g_memberIndexLetterUsed[CMHL_EnumValues].append(letter,md);
documentedClassMembers[CMHL_EnumValues]++;
}
else if (md->isProperty())
{
g_memberIndexLetterUsed[CMHL_Properties].append(letter,md);
documentedClassMembers[CMHL_Properties]++;
}
else if (md->isEvent())
{
g_memberIndexLetterUsed[CMHL_Events].append(letter,md);
documentedClassMembers[CMHL_Events]++;
}
else if (md->isRelated() || md->isForeign() ||
(md->isFriend() && !isFriendToHide))
{
g_memberIndexLetterUsed[CMHL_Related].append(letter,md);
documentedClassMembers[CMHL_Related]++;
}
}
}
}
void addFileMemberNameToIndex ( MemberDef *  md)

Definition at line 2407 of file index.cpp.

References LetterToIndexMap< T >::append(), documentedFileMembers, FMHL_All, FMHL_Defines, FMHL_Enums, FMHL_EnumValues, FMHL_Functions, FMHL_Typedefs, FMHL_Variables, MemberDef::getEnumScope(), MemberDef::getFileDef(), getPrefixIndex(), getUtf8CodeToLower(), MemberDef::isDefine(), MemberDef::isEnumerate(), MemberDef::isEnumValue(), MemberDef::isFunction(), FileDef::isLinkableInProject(), MemberDef::isLinkableInProject(), MemberDef::isStrong(), MemberDef::isTypedef(), MemberDef::isVariable(), and Definition::name().

Referenced by addMembersToIndex().

{
FileDef *fd=md->getFileDef();
if (fd && fd->isLinkableInProject() && md->isLinkableInProject())
{
QCString n = md->name();
int index = getPrefixIndex(n);
uint letter = getUtf8CodeToLower(n,index);
if (!n.isEmpty())
{
if (!md->isEnumValue() || (md->getEnumScope() && !md->getEnumScope()->isStrong()))
{
g_fileIndexLetterUsed[FMHL_All].append(letter,md);
documentedFileMembers[FMHL_All]++;
}
if (md->isFunction())
{
g_fileIndexLetterUsed[FMHL_Functions].append(letter,md);
documentedFileMembers[FMHL_Functions]++;
}
else if (md->isVariable())
{
g_fileIndexLetterUsed[FMHL_Variables].append(letter,md);
documentedFileMembers[FMHL_Variables]++;
}
else if (md->isTypedef())
{
g_fileIndexLetterUsed[FMHL_Typedefs].append(letter,md);
documentedFileMembers[FMHL_Typedefs]++;
}
else if (md->isEnumerate())
{
g_fileIndexLetterUsed[FMHL_Enums].append(letter,md);
documentedFileMembers[FMHL_Enums]++;
}
else if (md->isEnumValue() && md->getEnumScope() && !md->getEnumScope()->isStrong())
{
g_fileIndexLetterUsed[FMHL_EnumValues].append(letter,md);
documentedFileMembers[FMHL_EnumValues]++;
}
else if (md->isDefine())
{
g_fileIndexLetterUsed[FMHL_Defines].append(letter,md);
documentedFileMembers[FMHL_Defines]++;
}
}
}
}
template<class T >
void addMembersToIndex ( T *  def,
LayoutDocManager::LayoutPart  part,
const QCString &  name,
const QCString &  anchor,
bool  addToIndex = TRUE,
bool  preventSeparateIndex = FALSE 
)

Definition at line 300 of file index.cpp.

References IndexList::addContentsItem(), MemberDef::anchor(), ClassDef::anchor(), LayoutDocManager::Class, LayoutDocEntry::ClassNestedClasses, Config_getBool, IndexList::decContentsDepth(), ClassDef::displayName(), MemberDef::enumFieldList(), LayoutDocEntry::FileClasses, Definition::getOuterScope(), MemberDef::getOutputFileBase(), MemberDef::getReference(), Doxygen::globalScope, MemberDef::hasDocumentation(), IndexList::incContentsDepth(), Doxygen::indexList, LayoutDocManager::instance(), ClassDef::isEmbeddedInOuterScope(), MemberDef::isEnumerate(), ClassDef::isLinkable(), ClassDef::isSimple(), MemberDef::isStatic(), SDict< ClassDef >::Iterator, LayoutDocEntry::kind(), LayoutDocEntry::MemberDef, Definition::name(), LayoutDocEntry::NamespaceClasses, Definition::partOfGroups(), LayoutDocEntryMemberDef::type, DefinitionIntf::TypeClass, and DefinitionIntf::TypeGroup.

Referenced by writeClassTree(), writeDirHierarchy(), writeDirTreeNode(), and writeGroupTreeNode().

{
bool hasMembers = def->getMemberLists().count()>0 || def->getMemberGroupSDict()!=0;
Doxygen::indexList->addContentsItem(hasMembers,name,
def->getReference(),def->getOutputFileBase(),anchor,
hasMembers && !preventSeparateIndex,
addToIndex,
def);
int numClasses=0;
ClassSDict *classes = def->getClassSDict();
if (classes)
{
ClassDef *cd;
ClassSDict::Iterator it(*classes);
for (;(cd=it.current());++it)
{
if (cd->isLinkable()) numClasses++;
}
}
//printf("addMembersToIndex(def=%s hasMembers=%d numClasses=%d)\n",def->name().data(),hasMembers,numClasses);
if (hasMembers || numClasses>0)
{
Doxygen::indexList->incContentsDepth();
QListIterator<LayoutDocEntry> eli(LayoutDocManager::instance().docEntries(part));
LayoutDocEntry *lde;
for (eli.toFirst();(lde=eli.current());++eli)
{
if (lde->kind()==LayoutDocEntry::MemberDef)
{
LayoutDocEntryMemberDef *lmd = (LayoutDocEntryMemberDef*)lde;
MemberList *ml = def->getMemberList(lmd->type);
if (ml)
{
MemberListIterator mi(*ml);
MemberDef *md;
for (mi.toFirst();(md=mi.current());++mi)
{
MemberList *enumList = md->enumFieldList();
bool isDir = enumList!=0 && md->isEnumerate();
bool isAnonymous = md->name().find('@')!=-1;
static bool hideUndocMembers = Config_getBool(HIDE_UNDOC_MEMBERS);
static bool extractStatic = Config_getBool(EXTRACT_STATIC);
if (!isAnonymous &&
(!hideUndocMembers || md->hasDocumentation()) &&
(!md->isStatic() || extractStatic)
)
{
if (md->getOuterScope()==def || md->getOuterScope()==Doxygen::globalScope)
{
Doxygen::indexList->addContentsItem(isDir,
md->name(),md->getReference(),md->getOutputFileBase(),md->anchor(),FALSE,addToIndex);
}
else // inherited member
{
Doxygen::indexList->addContentsItem(isDir,
md->name(),def->getReference(),def->getOutputFileBase(),md->anchor(),FALSE,addToIndex);
}
}
if (isDir)
{
if (!isAnonymous)
{
Doxygen::indexList->incContentsDepth();
}
MemberListIterator emli(*enumList);
MemberDef *emd;
for (emli.toFirst();(emd=emli.current());++emli)
{
if (!hideUndocMembers || emd->hasDocumentation())
{
if (emd->getOuterScope()==def || emd->getOuterScope()==Doxygen::globalScope)
{
Doxygen::indexList->addContentsItem(FALSE,
emd->name(),emd->getReference(),emd->getOutputFileBase(),emd->anchor(),FALSE,addToIndex);
}
else // inherited member
{
Doxygen::indexList->addContentsItem(FALSE,
emd->name(),def->getReference(),def->getOutputFileBase(),emd->anchor(),FALSE,addToIndex);
}
}
}
if (!isAnonymous)
{
Doxygen::indexList->decContentsDepth();
}
}
}
}
}
else if (lde->kind()==LayoutDocEntry::NamespaceClasses ||
lde->kind()==LayoutDocEntry::FileClasses ||
lde->kind()==LayoutDocEntry::ClassNestedClasses
)
{
if (classes)
{
ClassDef *cd;
ClassSDict::Iterator it(*classes);
for (;(cd=it.current());++it)
{
if (cd->isLinkable() && (cd->partOfGroups()==0 || def->definitionType()==Definition::TypeGroup))
{
static bool inlineSimpleStructs = Config_getBool(INLINE_SIMPLE_STRUCTS);
bool isNestedClass = def->definitionType()==Definition::TypeClass;
addMembersToIndex(cd,LayoutDocManager::Class,cd->displayName(FALSE),cd->anchor(),
addToIndex && (isNestedClass || (cd->isSimple() && inlineSimpleStructs)),
preventSeparateIndex || cd->isEmbeddedInOuterScope());
}
}
}
}
}
Doxygen::indexList->decContentsDepth();
}
}
void addNamespaceMemberNameToIndex ( MemberDef *  md)

Definition at line 2350 of file index.cpp.

References LetterToIndexMap< T >::append(), documentedNamespaceMembers, MemberDef::getEnumScope(), MemberDef::getNamespaceDef(), getPrefixIndex(), getUtf8CodeToLower(), MemberDef::isEnumerate(), MemberDef::isEnumValue(), MemberDef::isFunction(), NamespaceDef::isLinkableInProject(), MemberDef::isLinkableInProject(), MemberDef::isStrong(), MemberDef::isTypedef(), MemberDef::isVariable(), Definition::name(), NMHL_All, NMHL_Enums, NMHL_EnumValues, NMHL_Functions, NMHL_Typedefs, and NMHL_Variables.

Referenced by addMembersToIndex().

{
NamespaceDef *nd=md->getNamespaceDef();
if (nd && nd->isLinkableInProject() && md->isLinkableInProject())
{
QCString n = md->name();
int index = getPrefixIndex(n);
uint letter = getUtf8CodeToLower(n,index);
if (!n.isEmpty())
{
if (!md->isEnumValue() || (md->getEnumScope() && !md->getEnumScope()->isStrong()))
{
g_namespaceIndexLetterUsed[NMHL_All].append(letter,md);
documentedNamespaceMembers[NMHL_All]++;
}
if (md->isFunction())
{
g_namespaceIndexLetterUsed[NMHL_Functions].append(letter,md);
documentedNamespaceMembers[NMHL_Functions]++;
}
else if (md->isVariable())
{
g_namespaceIndexLetterUsed[NMHL_Variables].append(letter,md);
documentedNamespaceMembers[NMHL_Variables]++;
}
else if (md->isTypedef())
{
g_namespaceIndexLetterUsed[NMHL_Typedefs].append(letter,md);
documentedNamespaceMembers[NMHL_Typedefs]++;
}
else if (md->isEnumerate())
{
g_namespaceIndexLetterUsed[NMHL_Enums].append(letter,md);
documentedNamespaceMembers[NMHL_Enums]++;
}
else if (md->isEnumValue() && md->getEnumScope() && !md->getEnumScope()->isStrong())
{
g_namespaceIndexLetterUsed[NMHL_EnumValues].append(letter,md);
documentedNamespaceMembers[NMHL_EnumValues]++;
}
}
}
}
static int countAnnotatedClasses ( int *  cp)
static

Definition at line 1556 of file index.cpp.

References Doxygen::classSDict, ClassDef::isEmbeddedInOuterScope(), ClassDef::isLinkableInProject(), SDict< ClassDef >::Iterator, and ClassDef::templateMaster().

Referenced by countDataStructures().

{
int count=0;
int countPrinted=0;
ClassSDict::Iterator cli(*Doxygen::classSDict);
ClassDef *cd;
for (;(cd=cli.current());++cli)
{
if (cd->isLinkableInProject() && cd->templateMaster()==0)
{
if (!cd->isEmbeddedInOuterScope())
{
countPrinted++;
}
count++;
}
}
*cp = countPrinted;
return count;
}
static int countClassesInTreeList ( const ClassSDict &  cl)
static

Definition at line 923 of file index.cpp.

References ClassDef::baseClasses(), hasVisibleRoot(), ClassDef::isVisibleInHierarchy(), SDict< ClassDef >::Iterator, and ClassDef::subClasses().

Referenced by countClassHierarchy().

{
int count=0;
ClassSDict::Iterator cli(cl);
ClassDef *cd;
for (;(cd=cli.current());++cli)
{
if (!hasVisibleRoot(cd->baseClasses())) // filter on root classes
{
if (cd->isVisibleInHierarchy()) // should it be visible
{
if (cd->subClasses()) // should have sub classes
{
count++;
}
}
}
}
return count;
}
static int countClassHierarchy ( )
static

Definition at line 944 of file index.cpp.

References Doxygen::classSDict, countClassesInTreeList(), Doxygen::hiddenClasses, and initClassHierarchy().

Referenced by countDataStructures().

{
int count=0;
initClassHierarchy(Doxygen::classSDict);
initClassHierarchy(Doxygen::hiddenClasses);
count+=countClassesInTreeList(*Doxygen::classSDict);
count+=countClassesInTreeList(*Doxygen::hiddenClasses);
return count;
}
void countDataStructures ( )

Definition at line 77 of file index.cpp.

References annotatedClasses, annotatedClassesPrinted, countAnnotatedClasses(), countClassHierarchy(), countDirs(), countFiles(), countGroups(), countNamespaces(), countRelatedPages(), documentedDirs, documentedFiles, documentedGroups, documentedHtmlFiles, documentedNamespaces, documentedPages, hierarchyClasses, and indexedPages.

Referenced by parseInput().

{
annotatedClasses = countAnnotatedClasses(&annotatedClassesPrinted); // "classes" + "annotated"
hierarchyClasses = countClassHierarchy(); // "hierarchy"
countFiles(documentedHtmlFiles,documentedFiles); // "files"
countRelatedPages(documentedPages,indexedPages); // "pages"
documentedGroups = countGroups(); // "modules"
documentedNamespaces = countNamespaces(); // "namespaces"
documentedDirs = countDirs(); // "dirs"
// "globals"
// "namespacemembers"
// "functions"
}
static int countDirs ( )
static

Definition at line 3232 of file index.cpp.

References Doxygen::directories, DirDef::isLinkableInProject(), and DirDef::visited.

Referenced by countDataStructures().

{
int count=0;
SDict<DirDef>::Iterator dli(*Doxygen::directories);
DirDef *dd;
for (dli.toFirst();(dd=dli.current());++dli)
{
if (dd->isLinkableInProject())
{
dd->visited=FALSE;
count++;
}
}
return count;
}
static void countFiles ( int &  htmlFiles,
int &  files 
)
static

Definition at line 1063 of file index.cpp.

References doc, fileVisibleInIndex(), and Doxygen::inputNameList.

Referenced by countDataStructures().

{
htmlFiles=0;
files=0;
FileNameListIterator fnli(*Doxygen::inputNameList);
FileName *fn;
for (;(fn=fnli.current());++fnli)
{
FileNameIterator fni(*fn);
FileDef *fd;
for (;(fd=fni.current());++fni)
{
bool doc,src;
doc = fileVisibleInIndex(fd,src);
if (doc || src)
{
htmlFiles++;
}
if (doc)
{
files++;
}
}
}
}
static int countGroups ( )
static

Definition at line 3214 of file index.cpp.

References Doxygen::groupSDict, Definition::isReference(), SDict< GroupDef >::Iterator, and GroupDef::visited.

Referenced by countDataStructures().

{
int count=0;
GroupSDict::Iterator gli(*Doxygen::groupSDict);
GroupDef *gd;
for (gli.toFirst();(gd=gli.current());++gli)
{
if (!gd->isReference())
{
gd->visited=FALSE;
count++;
}
}
return count;
}
static int countNamespaces ( )
static

Definition at line 1306 of file index.cpp.

References NamespaceDef::isLinkableInProject(), SDict< NamespaceDef >::Iterator, and Doxygen::namespaceSDict.

Referenced by countDataStructures().

{
int count=0;
NamespaceSDict::Iterator nli(*Doxygen::namespaceSDict);
NamespaceDef *nd;
for (;(nd=nli.current());++nli)
{
if (nd->isLinkableInProject()) count++;
}
return count;
}
static void countRelatedPages ( int &  docPages,
int &  indexPages 
)
static

Definition at line 3071 of file index.cpp.

References PageDef::documentedPage(), SDict< PageDef >::Iterator, Doxygen::pageSDict, and PageDef::visibleInIndex().

Referenced by countDataStructures().

{
docPages=indexPages=0;
PageSDict::Iterator pdi(*Doxygen::pageSDict);
PageDef *pd=0;
for (pdi.toFirst();(pd=pdi.current());++pdi)
{
if ( pd->visibleInIndex())
{
indexPages++;
}
if ( pd->documentedPage())
{
docPages++;
}
}
}
static bool dirHasVisibleChildren ( DirDef *  dd)
static

Definition at line 541 of file index.cpp.

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

Referenced by writeDirTreeNode().

{
if (dd->hasDocumentation()) return TRUE;
QListIterator<FileDef> fli(*dd->getFiles());
FileDef *fd;
for (fli.toFirst();(fd=fli.current());++fli)
{
bool genSourceFile;
if (fileVisibleInIndex(fd,genSourceFile))
{
return TRUE;
}
if (genSourceFile)
{
return TRUE;
}
}
QListIterator<DirDef> dli(dd->subDirs());
DirDef *subdd;
for (dli.toFirst();(subdd=dli.current());++dli)
{
if (dirHasVisibleChildren(subdd))
{
return TRUE;
}
}
return FALSE;
}
void endFile ( OutputList &  ol,
bool  skipNavIndex,
bool  skipEndContents,
const QCString &  navPath 
)

Definition at line 264 of file index.cpp.

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

Referenced by endFileWithNavPath(), generateExampleDocs(), writeAlphabeticalIndex(), writeAnnotatedIndex(), writeClassMemberIndexFiltered(), PageDef::writeDocumentation(), GroupDef::writeDocumentation(), MemberList::writeDocumentationPage(), writeExampleIndex(), writeFileIndex(), writeFileMemberIndexFiltered(), writeGraphicalClassHierarchy(), writeGraphInfo(), writeGroupIndex(), writeHierarchicalIndex(), writeIndex(), ClassDef::writeMemberList(), writeNamespaceIndex(), writeNamespaceMemberIndexFiltered(), writePageIndex(), and writeUserGroupStubPage().

{
static bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::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();
}
void endFileWithNavPath ( Definition *  d,
OutputList &  ol 
)

Definition at line 283 of file index.cpp.

References Config_getBool, OutputList::disableAllBut(), endFile(), OutputGenerator::Html, Definition::navigationPathAsString(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), and OutputList::writeString().

Referenced by NamespaceDef::writeDocumentation(), PageDef::writeDocumentation(), DirDef::writeDocumentation(), FileDef::writeDocumentation(), DirRelation::writeDocumentation(), ClassDef::writeDocumentation(), MemberList::writeDocumentationPage(), and FileDef::writeSource().

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

Definition at line 104 of file index.cpp.

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

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

{
ol.pushGeneratorState();
ol.disable(OutputGenerator::Man);
ol.disable(OutputGenerator::Html);
if (level<6) ol.endIndexList();
ol.enableAll();
ol.disable(OutputGenerator::Latex);
ol.disable(OutputGenerator::RTF);
ol.endItemList();
ol.popGeneratorState();
}
static void endQuickIndexItem ( OutputList &  ol)
static

Definition at line 213 of file index.cpp.

References OutputList::writeString().

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

{
bool fancyTabs=TRUE;
if (fancyTabs) ol.writeString("</span>");
ol.writeString("</a>");
if (fancyTabs) ol.writeString("</li>\n");
}
static void endQuickIndexList ( OutputList &  ol)
static

Definition at line 170 of file index.cpp.

References OutputList::writeString().

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

{
bool fancyTabs = TRUE;
if (fancyTabs)
{
ol.writeString(" </ul>\n");
}
ol.writeString(" </div>\n");
}
void endTitle ( OutputList &  ol,
const char *  fileName,
const char *  name 
)

Definition at line 237 of file index.cpp.

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

Referenced by generateExampleDocs(), writeAlphabeticalIndex(), writeAnnotatedIndex(), NamespaceDef::writeDocumentation(), PageDef::writeDocumentation(), DirDef::writeDocumentation(), FileDef::writeDocumentation(), ClassDef::writeDocumentation(), writeExampleIndex(), writeFileIndex(), writeGraphicalClassHierarchy(), writeGraphInfo(), writeGroupIndex(), writeHierarchicalIndex(), ClassDef::writeMemberList(), writeNamespaceIndex(), writePageIndex(), FileDef::writeSource(), and writeUserGroupStubPage().

{
ol.popGeneratorState();
ol.endTitleHead(fileName,name);
ol.endHeaderSection();
}
QCString fixSpaces ( const QCString &  s)

Definition at line 223 of file index.cpp.

References substitute().

Referenced by renderQuickLinksAsTabs(), renderQuickLinksAsTree(), writeClassMemberIndexFiltered(), writeFileMemberIndexFiltered(), writeNamespaceMemberIndexFiltered(), and writeUserGroupStubPage().

{
return substitute(s," ","&#160;");
}
static const CmhlInfo* getCmhlInfo ( int  hl)
static

Definition at line 2498 of file index.cpp.

References Config_getBool, theTranslator, Translator::trAll(), Translator::trEnumerations(), Translator::trEnumerationValues(), Translator::trEvents(), VhdlDocGen::trFunctionAndProc(), Translator::trFunctions(), Translator::trProperties(), Translator::trRelatedFunctions(), Translator::trSubprograms(), Translator::trTypedefs(), and Translator::trVariables().

Referenced by renderQuickLinksAsJs(), and writeClassMemberIndexFiltered().

{
static bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
static bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
static CmhlInfo cmhlInfo[] =
{
CmhlInfo("functions", theTranslator->trAll()),
CmhlInfo("functions_func",
fortranOpt ? theTranslator->trSubprograms() :
vhdlOpt ? VhdlDocGen::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->trRelatedFunctions())
};
return &cmhlInfo[hl];
}
static const FmhlInfo* getFmhlInfo ( int  hl)
static

Definition at line 2675 of file index.cpp.

References Config_getBool, theTranslator, Translator::trAll(), Translator::trDefines(), Translator::trEnumerations(), Translator::trEnumerationValues(), VhdlDocGen::trFunctionAndProc(), Translator::trFunctions(), Translator::trSubprograms(), Translator::trTypedefs(), and Translator::trVariables().

Referenced by renderQuickLinksAsJs(), and writeFileMemberIndexFiltered().

{
static bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
static bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
static FmhlInfo fmhlInfo[] =
{
FmhlInfo("globals", theTranslator->trAll()),
FmhlInfo("globals_func",
fortranOpt ? theTranslator->trSubprograms() :
vhdlOpt ? VhdlDocGen::trFunctionAndProc() :
theTranslator->trFunctions()),
FmhlInfo("globals_vars",theTranslator->trVariables()),
FmhlInfo("globals_type",theTranslator->trTypedefs()),
FmhlInfo("globals_enum",theTranslator->trEnumerations()),
FmhlInfo("globals_eval",theTranslator->trEnumerationValues()),
FmhlInfo("globals_defs",theTranslator->trDefines())
};
return &fmhlInfo[hl];
}
static const NmhlInfo* getNmhlInfo ( int  hl)
static

Definition at line 2842 of file index.cpp.

References Config_getBool, theTranslator, Translator::trAll(), Translator::trEnumerations(), Translator::trEnumerationValues(), VhdlDocGen::trFunctionAndProc(), Translator::trFunctions(), Translator::trSubprograms(), Translator::trTypedefs(), and Translator::trVariables().

Referenced by renderQuickLinksAsJs(), and writeNamespaceMemberIndexFiltered().

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

Definition at line 2255 of file index.cpp.

References SIntDict< T >::clear(), CMHL_Total, and documentedClassMembers.

Referenced by initDoxygen().

{
int j=0;
for (j=0;j<CMHL_Total;j++)
{
documentedClassMembers[j]=0;
g_memberIndexLetterUsed[j].clear();
}
}
void initFileMemberIndices ( )

Definition at line 2397 of file index.cpp.

References SIntDict< T >::clear(), documentedFileMembers, and NMHL_Total.

Referenced by initDoxygen().

{
int j=0;
for (j=0;j<NMHL_Total;j++)
{
documentedFileMembers[j]=0;
g_fileIndexLetterUsed[j].clear();
}
}
void initNamespaceMemberIndices ( )

Definition at line 2340 of file index.cpp.

References SIntDict< T >::clear(), documentedNamespaceMembers, and NMHL_Total.

Referenced by initDoxygen().

{
int j=0;
for (j=0;j<NMHL_Total;j++)
{
documentedNamespaceMembers[j]=0;
g_namespaceIndexLetterUsed[j].clear();
}
}
static QCString letterToLabel ( uint  startLetter)
static

Definition at line 1641 of file index.cpp.

References isId().

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

{
char s[11]; // max 0x12345678 + '\0'
if (isId(startLetter)) // printable ASCII character
{
s[0]=(char)startLetter;
s[1]=0;
}
else
{
const char hex[]="0123456789abcdef";
int i=0;
s[i++]='0';
s[i++]='x';
if (startLetter>(1<<24)) // 4 byte character
{
s[i++]=hex[(startLetter>>28)&0xf];
s[i++]=hex[(startLetter>>24)&0xf];
}
if (startLetter>(1<<16)) // 3 byte character
{
s[i++]=hex[(startLetter>>20)&0xf];
s[i++]=hex[(startLetter>>16)&0xf];
}
if (startLetter>(1<<8)) // 2 byte character
{
s[i++]=hex[(startLetter>>12)&0xf];
s[i++]=hex[(startLetter>>8)&0xf];
}
// one byte character
s[i++]=hex[(startLetter>>4)&0xf];
s[i++]=hex[(startLetter>>0)&0xf];
s[i++]=0;
}
return s;
}
static bool mainPageHasOwnTitle ( )
static

Definition at line 3091 of file index.cpp.

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

Referenced by writePages().

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

Definition at line 4285 of file index.cpp.

References annotatedClasses, LayoutNavEntry::Classes, LayoutNavEntry::ClassHierarchy, LayoutNavEntry::ClassIndex, LayoutNavEntry::ClassList, LayoutNavEntry::ClassMembers, CMHL_All, Config_getBool, SDict< T >::count(), documentedClassMembers, documentedFileMembers, documentedGroups, documentedHtmlFiles, documentedNamespaceMembers, documentedNamespaces, LayoutNavEntry::Examples, Doxygen::exampleSDict, LayoutNavEntry::FileGlobals, LayoutNavEntry::FileList, LayoutNavEntry::Files, FMHL_All, hierarchyClasses, indexedPages, LayoutNavEntry::MainPage, LayoutNavEntry::Modules, LayoutNavEntry::NamespaceList, LayoutNavEntry::NamespaceMembers, LayoutNavEntry::Namespaces, NMHL_All, LayoutNavEntry::Pages, LayoutNavEntry::User, and LayoutNavEntry::UserGroup.

Referenced by renderQuickLinksAsJs().

{
static bool showFiles = Config_getBool(SHOW_FILES);
static bool showNamespaces = Config_getBool(SHOW_NAMESPACES);
switch (kind)
{
case LayoutNavEntry::MainPage: return TRUE;
case LayoutNavEntry::User: return TRUE;
case LayoutNavEntry::UserGroup: return TRUE;
case LayoutNavEntry::Pages: return indexedPages>0;
case LayoutNavEntry::Modules: return documentedGroups>0;
case LayoutNavEntry::Namespaces: return documentedNamespaces>0 && showNamespaces;
case LayoutNavEntry::NamespaceList: return documentedNamespaces>0 && showNamespaces;
case LayoutNavEntry::NamespaceMembers: return documentedNamespaceMembers[NMHL_All]>0;
case LayoutNavEntry::Classes: return annotatedClasses>0;
case LayoutNavEntry::ClassList: return annotatedClasses>0;
case LayoutNavEntry::ClassIndex: return annotatedClasses>0;
case LayoutNavEntry::ClassHierarchy: return hierarchyClasses>0;
case LayoutNavEntry::ClassMembers: return documentedClassMembers[CMHL_All]>0;
case LayoutNavEntry::Files: return documentedHtmlFiles>0 && showFiles;
case LayoutNavEntry::FileList: return documentedHtmlFiles>0 && showFiles;
case LayoutNavEntry::FileGlobals: return documentedFileMembers[FMHL_All]>0;
//case LayoutNavEntry::Dirs: return documentedDirs>0;
case LayoutNavEntry::Examples: return Doxygen::exampleSDict->count()>0;
}
return FALSE;
}
template<class T >
void renderMemberIndicesAsJs ( FTextStream &  t,
int  total,
const int *  numDocumented,
const LetterToIndexMap< MemberIndexList > *  memberLists,
const T *(*)(int hl)  getInfo 
)

Definition at line 4314 of file index.cpp.

References convertToJSString(), SIntDict< T >::Iterator::current(), endl(), Doxygen::htmlFileExtension, MemberIndexList::letter(), letterToLabel(), MAX_ITEMS_BEFORE_MULTIPAGE_INDEX, maxItemsBeforeQuickIndex, and SIntDict< T >::Iterator::toFirst().

Referenced by renderQuickLinksAsJs().

{
// index items per category member lists
bool firstMember=TRUE;
for (int i=0;i<total;i++)
{
if (numDocumented[i]>0)
{
t << ",";
if (firstMember)
{
t << "children:[";
firstMember=FALSE;
}
t << endl << "{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:[" << endl;
bool firstLetter=TRUE;
SIntDict<MemberIndexList>::Iterator it(memberLists[i]);
MemberIndexList *ml;
for (it.toFirst();(ml=it.current());++it)
{
if (!firstLetter) t << "," << endl;
uint letter = ml->letter();
QCString is = letterToLabel(letter);
QCString ci = QString(QChar(letter)).utf8();
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+is) << "'}";
firstLetter=FALSE;
}
t << "]";
}
t << "}";
}
}
if (!firstMember)
{
t << "]";
}
}
static bool renderQuickLinksAsJs ( FTextStream &  t,
LayoutNavEntry *  root,
bool  first 
)
static

Definition at line 4375 of file index.cpp.

References LayoutNavEntry::children(), LayoutNavEntry::ClassMembers, CMHL_Total, convertToJSString(), documentedClassMembers, documentedFileMembers, documentedNamespaceMembers, endl(), LayoutNavEntry::FileGlobals, FMHL_Total, getCmhlInfo(), getFmhlInfo(), getNmhlInfo(), LayoutNavEntry::NamespaceMembers, NMHL_Total, quickLinkVisible(), and renderMemberIndicesAsJs().

Referenced by writeMenuData().

{
QListIterator<LayoutNavEntry> li(root->children());
LayoutNavEntry *entry;
int count=0;
for (li.toFirst();(entry=li.current());++li)
{
if (entry->visible() && quickLinkVisible(entry->kind())) count++;
}
if (count>0) // at least one item is visible
{
bool firstChild = TRUE;
if (!first) t << ",";
t << "children:[" << endl;
for (li.toFirst();(entry=li.current());++li)
{
if (entry->visible() && quickLinkVisible(entry->kind()))
{
if (!firstChild) t << "," << endl;
firstChild=FALSE;
QCString url = entry->url();
t << "{text:'" << convertToJSString(entry->title()) << "',url:'"
<< convertToJSString(url) << "'";
bool hasChildren=FALSE;
if (entry->kind()==LayoutNavEntry::NamespaceMembers)
{
renderMemberIndicesAsJs(t,NMHL_Total,documentedNamespaceMembers,
g_namespaceIndexLetterUsed,getNmhlInfo);
}
else if (entry->kind()==LayoutNavEntry::ClassMembers)
{
renderMemberIndicesAsJs(t,CMHL_Total,documentedClassMembers,
g_memberIndexLetterUsed,getCmhlInfo);
}
else if (entry->kind()==LayoutNavEntry::FileGlobals)
{
renderMemberIndicesAsJs(t,FMHL_Total,documentedFileMembers,
g_fileIndexLetterUsed,getFmhlInfo);
}
else // recursive into child list
{
hasChildren = renderQuickLinksAsJs(t,entry,FALSE);
}
if (hasChildren) t << "]";
t << "}";
}
}
}
return count>0;
}
void startFile ( OutputList &  ol,
const char *  name,
const char *  manName,
const char *  title,
HighlightedItem  hli,
bool  additionalIndices,
const char *  altSidebarName 
)

Definition at line 244 of file index.cpp.

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

Referenced by generateExampleDocs(), writeAlphabeticalIndex(), writeAnnotatedIndex(), NamespaceDef::writeDocumentation(), PageDef::writeDocumentation(), GroupDef::writeDocumentation(), DirDef::writeDocumentation(), FileDef::writeDocumentation(), DirRelation::writeDocumentation(), ClassDef::writeDocumentation(), MemberList::writeDocumentationPage(), writeExampleIndex(), writeFileIndex(), writeGraphicalClassHierarchy(), writeGraphInfo(), writeGroupIndex(), writeHierarchicalIndex(), writeIndex(), ClassDef::writeMemberList(), writeNamespaceIndex(), writePageIndex(), FileDef::writeSource(), and writeUserGroupStubPage().

{
static bool disableIndex = Config_getBool(DISABLE_INDEX);
ol.startFile(name,manName,title);
ol.startQuickIndices();
if (!disableIndex)
{
ol.writeQuickLinks(TRUE,hli,name);
}
if (!additionalIndices)
{
ol.endQuickIndices();
}
ol.writeSplitBar(altSidebarName ? altSidebarName : name);
ol.writeSearchInfo();
resetDotNodeNumbering();
}
static void startIndexHierarchy ( OutputList &  ol,
int  level 
)
static

Definition at line 91 of file index.cpp.

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

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

{
ol.pushGeneratorState();
ol.disable(OutputGenerator::Man);
ol.disable(OutputGenerator::Html);
if (level<6) ol.startIndexList();
ol.enableAll();
ol.disable(OutputGenerator::Latex);
ol.disable(OutputGenerator::RTF);
ol.startItemList();
ol.popGeneratorState();
}
static void startQuickIndexItem ( OutputList &  ol,
const char *  l,
bool  hl,
bool  compact,
bool &  first 
)
static

Definition at line 180 of file index.cpp.

References OutputList::writeString().

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

{
bool fancyTabs = TRUE;
if (!first && compact && !fancyTabs) ol.writeString(" | ");
first=FALSE;
if (fancyTabs)
{
ol.writeString(" <li");
if (hl) ol.writeString(" class=\"current\"");
ol.writeString("><a ");
}
else
{
if (!compact) ol.writeString("<li>");
if (hl && compact)
{
ol.writeString("<a class=\"qindexHL\" ");
}
else
{
ol.writeString("<a class=\"qindex\" ");
}
}
ol.writeString("href=\"");
ol.writeString(l);
ol.writeString("\">");
if (fancyTabs)
{
ol.writeString("<span>");
}
}
static void startQuickIndexList ( OutputList &  ol,
bool  letterTabs = FALSE 
)
static

Definition at line 149 of file index.cpp.

References OutputList::writeString().

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

{
bool fancyTabs = TRUE;
if (fancyTabs)
{
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");
}
else
{
ol.writeString(" <div class=\"qindex\">");
}
}
void startTitle ( OutputList &  ol,
const char *  fileName,
Definition *  def 
)

Definition at line 228 of file index.cpp.

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

Referenced by generateExampleDocs(), writeAlphabeticalIndex(), writeAnnotatedIndex(), NamespaceDef::writeDocumentation(), PageDef::writeDocumentation(), DirDef::writeDocumentation(), FileDef::writeDocumentation(), ClassDef::writeDocumentation(), writeExampleIndex(), writeFileIndex(), writeGraphicalClassHierarchy(), writeGraphInfo(), writeGroupIndex(), writeHierarchicalIndex(), ClassDef::writeMemberList(), writeNamespaceIndex(), writePageIndex(), FileDef::writeSource(), and writeUserGroupStubPage().

{
ol.startHeaderSection();
if (def) def->writeSummaryLinks(ol);
ol.startTitleHead(fileName);
ol.pushGeneratorState();
ol.disable(OutputGenerator::Man);
}
static void writeAlphabeticalClassList ( OutputList &  ol)
static

Definition at line 1761 of file index.cpp.

References UsedIndexLetters::add(), ClassDef::anchor(), annotatedClasses, LetterToIndexMap< T >::append(), AlphaIndexTableCell::classDef(), ClassDef::className(), Doxygen::classSDict, Config_getInt, SIntDict< T >::Iterator::current(), OutputList::docify(), VhdlDocGen::ENTITYCLASS, extractNamespaceName(), Definition::getLanguage(), getLanguageSpecificSeparator(), NamespaceDef::getOutputFileBase(), ClassDef::getOutputFileBase(), getPrefixIndex(), ClassDef::getReference(), Definition::getReference(), getResolvedNamespace(), getUtf8CodeToLower(), NamespaceDef::isLinkable(), ClassDef::isLinkableInProject(), SDict< ClassDef >::Iterator, PrefixIgnoreClassList::letter(), AlphaIndexTableCell::letter(), letterToLabel(), Definition::name(), NEXT_ROW, ClassDef::protection(), AlphaIndexTableCell::row(), SIntDict< T >::sort(), SrcLangExt_VHDL, substitute(), ClassDef::templateMaster(), SIntDict< T >::Iterator::toFirst(), OutputList::writeNonBreakableSpace(), OutputList::writeObjectLink(), and OutputList::writeString().

Referenced by writeAlphabeticalIndex().

{
// What starting letters are used
UsedIndexLetters indexLettersUsed;
// first count the number of headers
ClassSDict::Iterator cli(*Doxygen::classSDict);
ClassDef *cd;
uint startLetter=0;
int headerItems=0;
for (;(cd=cli.current());++cli)
{
if (cd->isLinkableInProject() && cd->templateMaster()==0)
{
if (cd->getLanguage()==SrcLangExt_VHDL && !((VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::ENTITYCLASS ))// no architecture
continue;
int index = getPrefixIndex(cd->className());
//printf("name=%s index=%d %d\n",cd->className().data(),index,cd->protection());
startLetter=getUtf8CodeToLower(cd->className(),index);
indexLettersUsed.add(startLetter);
}
}
indexLettersUsed.sort();
// write quick link index (row of letters)
QCString alphaLinks = "<div class=\"qindex\">";
SIntDict<uint>::Iterator it(indexLettersUsed);
uint *pLetter;
for (it.toFirst();(pLetter=it.current());++it)
{
if (headerItems) alphaLinks += "&#160;|&#160;";
headerItems++;
QCString li = letterToLabel(*pLetter);
QCString ls = QString(QChar(*pLetter)).utf8();
alphaLinks += (QCString)"<a class=\"qindex\" href=\"#letter_" +
li + "\">" +
ls + "</a>";
}
alphaLinks += "</div>\n";
ol.writeString(alphaLinks);
// the number of columns in the table
const int columns = Config_getInt(COLS_IN_ALPHA_INDEX);
int i,j;
int totalItems = headerItems*2 + annotatedClasses; // number of items in the table (headers span 2 items)
int rows = (totalItems + columns - 1)/columns; // number of rows in the table
//printf("headerItems=%d totalItems=%d columns=%d rows=%d itemsInLastRow=%d\n",
// headerItems,totalItems,columns,rows,itemsInLastRow);
// Keep a list of classes for each starting letter
LetterToIndexMap<PrefixIgnoreClassList> classesByLetter;
AlphaIndexTableColumns tableColumns;
// fill the columns with the class list (row elements in each column,
// expect for the columns with number >= itemsInLastRow, which get one
// item less.
//int icount=0;
startLetter=0;
for (cli.toFirst();(cd=cli.current());++cli)
{
if (cd->getLanguage()==SrcLangExt_VHDL && !((VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::ENTITYCLASS ))// no architecture
continue;
if (cd->isLinkableInProject() && cd->templateMaster()==0)
{
int index = getPrefixIndex(cd->className());
startLetter=getUtf8CodeToLower(cd->className(),index);
// Do some sorting again, since the classes are sorted by name with
// prefix, which should be ignored really.
if (cd->getLanguage()==SrcLangExt_VHDL)
{
if ((VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::ENTITYCLASS )// no architecture
{
classesByLetter.append(startLetter,cd);
}
}
else
{
classesByLetter.append(startLetter,cd);
}
}
}
#define NEXT_ROW() \
do \
{ \
if (row>maxRows) maxRows=row; \
if (row>=rows && col<columns) \
{ \
col++; \
row=0; \
tableRows = new AlphaIndexTableRows; \
tableColumns.append(tableRows); \
} \
} \
while(0) \
AlphaIndexTableRows *tableRows = new AlphaIndexTableRows;
tableColumns.append(tableRows);
int col=0,row=0,maxRows=0;
PrefixIgnoreClassList *cl;
SIntDict<PrefixIgnoreClassList>::Iterator lit(classesByLetter);
for (lit.toFirst();(cl=lit.current());++lit)
{
uint l = cl->letter();
// add special header cell
tableRows->append(new AlphaIndexTableCell(row,col,l,(ClassDef*)0x8));
row++;
tableRows->append(new AlphaIndexTableCell(row,col,0,(ClassDef*)0x8));
row++;
ClassListIterator cit(*cl);
cit.toFirst();
ClassDef *cd = cit.current();
++cit;
tableRows->append(new AlphaIndexTableCell(row,col,0,cd));
row++;
NEXT_ROW();
for (;(cd=cit.current()); ++cit)
{
// add normal cell
tableRows->append(new AlphaIndexTableCell(row,col,0,cd));
row++;
NEXT_ROW();
}
}
// create row iterators for each column
AlphaIndexTableRowsIterator **colIterators = new AlphaIndexTableRowsIterator*[columns];
for (i=0;i<columns;i++)
{
if (i<(int)tableColumns.count())
{
colIterators[i] = new AlphaIndexTableRowsIterator(*tableColumns.at(i));
}
else // empty column
{
colIterators[i] = 0;
}
}
ol.writeString("<table class=\"classindex\">\n");
// generate table
for (i=0;i<=maxRows;i++) // foreach table row
{
//printf("writing row %d\n",i);
//ol.nextTableRow();
ol.writeString("<tr>");
// the last column may contain less items then the others
//int colsInRow = (i<rows-1) ? columns : itemsInLastRow;
//printf("row [%d]\n",i);
for (j=0;j<columns;j++) // foreach table column
{
if (colIterators[j])
{
AlphaIndexTableCell *cell = colIterators[j]->current();
if (cell)
{
if (cell->row()==i)
{
if (cell->letter()!=0)
{
QCString s = letterToLabel(cell->letter());
ol.writeString("<td rowspan=\"2\" valign=\"bottom\">");
ol.writeString("<a name=\"letter_");
ol.writeString(s);
ol.writeString("\"></a>");
ol.writeString("<table border=\"0\" cellspacing=\"0\" cellpadding=\"0\">"
"<tr>"
"<td><div class=\"ah\">&#160;&#160;");
ol.writeString(QString(QChar(cell->letter())).utf8());
ol.writeString( "&#160;&#160;</div>"
"</td>"
"</tr>"
"</table>\n");
}
else if (cell->classDef()!=(ClassDef*)0x8)
{
cd = cell->classDef();
ol.writeString("<td valign=\"top\">");
QCString namesp,cname;
//if (cd->getNamespaceDef()) namesp=cd->getNamespaceDef()->displayName();
//QCString cname=cd->className();
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.docify(" (");
NamespaceDef *nd = getResolvedNamespace(namesp);
if (nd && nd->isLinkable())
{
ol.writeObjectLink(nd->getReference(),
nd->getOutputFileBase(),0,nsDispName);
}
else
{
ol.docify(nsDispName);
}
ol.docify(")");
}
ol.writeNonBreakableSpace(3);
}
++(*colIterators[j]);
if (cell->letter()!=0 || cell->classDef()!=(ClassDef*)0x8)
{
ol.writeString("</td>");
}
}
}
else
{
ol.writeString("<td></td>");
}
}
}
ol.writeString("</tr>\n");
}
ol.writeString("</table>\n");
ol.writeString(alphaLinks);
// release the temporary memory
for (i=0;i<columns;i++)
{
delete colIterators[i];
}
delete[] colIterators;
}
static void writeAlphabeticalIndex ( OutputList &  ol)
static

Definition at line 2009 of file index.cpp.

References IndexList::addContentsItem(), annotatedClasses, LayoutNavEntry::ClassIndex, OutputList::disableAllBut(), endFile(), endTitle(), LayoutNavEntry::find(), HLI_Classes, OutputGenerator::Html, Doxygen::indexList, LayoutDocManager::instance(), OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), startFile(), startTitle(), theTranslator, LayoutNavEntry::title(), Translator::trCompoundIndex(), LayoutNavEntry::visible(), and writeAlphabeticalClassList().

Referenced by writeIndexHierarchyEntries().

{
if (annotatedClasses==0) return;
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassIndex);
QCString title = lne ? lne->title() : theTranslator->trCompoundIndex();
bool addToIndex = lne==0 || lne->visible();
startFile(ol,"classes",0,title,HLI_Classes);
startTitle(ol,0);
ol.parseText(title);
endTitle(ol,0,0);
if (addToIndex)
{
Doxygen::indexList->addContentsItem(FALSE,title,0,"classes",0,FALSE,TRUE);
}
ol.startContents();
writeAlphabeticalClassList(ol);
endFile(ol); // contains ol.endContents()
ol.popGeneratorState();
}
static void writeAnnotatedClassList ( OutputList &  ol)
static

Definition at line 1578 of file index.cpp.

References ClassDef::anchor(), Definition::briefDescription(), Definition::briefFile(), Definition::briefLine(), Doxygen::classSDict, OutputList::disable(), ClassDef::displayName(), OutputList::docify(), OutputList::endIndexKey(), OutputList::endIndexList(), OutputList::endIndexValue(), OutputList::generateDoc(), Definition::getLanguage(), ClassDef::getOutputFileBase(), VhdlDocGen::getProtectionName(), ClassDef::isEmbeddedInOuterScope(), ClassDef::isLinkableInProject(), SDict< ClassDef >::Iterator, OutputGenerator::Latex, VhdlDocGen::PACKAGECLASS, VhdlDocGen::PACKBODYCLASS, OutputList::popGeneratorState(), ClassDef::protection(), OutputList::pushGeneratorState(), OutputGenerator::RTF, SrcLangExt_VHDL, OutputList::startIndexKey(), OutputList::startIndexList(), OutputList::startIndexValue(), ClassDef::templateMaster(), OutputList::writeObjectLink(), and OutputList::writeString().

Referenced by writeAnnotatedIndex().

{
//LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassList);
//bool addToIndex = lne==0 || lne->visible();
ol.startIndexList();
ClassSDict::Iterator cli(*Doxygen::classSDict);
ClassDef *cd;
for (cli.toFirst();(cd=cli.current());++cli)
{
if (cd->getLanguage()==SrcLangExt_VHDL &&
((VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::PACKAGECLASS ||
(VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::PACKBODYCLASS)
) // no architecture
{
continue;
}
ol.pushGeneratorState();
if (cd->isEmbeddedInOuterScope())
{
ol.disable(OutputGenerator::Latex);
ol.disable(OutputGenerator::RTF);
}
if (cd->isLinkableInProject() && cd->templateMaster()==0)
{
ol.startIndexKey();
if (cd->getLanguage()==SrcLangExt_VHDL)
{
QCString prot= VhdlDocGen::getProtectionName((VhdlDocGen::VhdlClasses)cd->protection());
ol.docify(prot.data());
ol.writeString(" ");
}
ol.writeObjectLink(0,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,0,
cd->briefDescription(TRUE),
FALSE, // indexWords
FALSE, // isExample
0, // example name
TRUE, // single line
TRUE // link from index
);
}
ol.endIndexValue(cd->getOutputFileBase(),hasBrief);
//if (addToIndex)
//{
// addMembersToIndex(cd,LayoutDocManager::Class,cd->displayName(),cd->anchor());
//}
}
ol.popGeneratorState();
}
ol.endIndexList();
}
static void writeAnnotatedIndex ( OutputList &  ol)
static

Definition at line 2038 of file index.cpp.

References IndexList::addContentsItem(), annotatedClasses, annotatedClassesPrinted, LayoutNavEntry::Classes, LayoutNavEntry::ClassList, Doxygen::classSDict, IndexList::decContentsDepth(), OutputList::disable(), IndexList::disable(), OutputList::disableAllBut(), IndexList::enable(), endFile(), OutputList::endTextBlock(), endTitle(), LayoutNavEntry::find(), FTVHelp::generateTreeViewInline(), HLI_Annotated, OutputGenerator::Html, IndexList::incContentsDepth(), Doxygen::indexList, LayoutDocManager::instance(), LayoutNavEntry::intro(), OutputGenerator::Latex, OutputGenerator::Man, Doxygen::namespaceSDict, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), OutputGenerator::RTF, OutputList::startContents(), startFile(), OutputList::startTextBlock(), startTitle(), theTranslator, LayoutNavEntry::title(), Translator::trCompoundList(), Translator::trCompoundListDescription(), LayoutNavEntry::visible(), writeAnnotatedClassList(), writeClassTree(), writeNamespaceTree(), and OutputList::writeString().

Referenced by writeIndexHierarchyEntries().

{
//printf("writeAnnotatedIndex: count=%d printed=%d\n",
// annotatedClasses,annotatedClassesPrinted);
if (annotatedClasses==0) return;
ol.pushGeneratorState();
ol.disable(OutputGenerator::Man);
if (annotatedClassesPrinted==0)
{
ol.disable(OutputGenerator::Latex);
ol.disable(OutputGenerator::RTF);
}
LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassList);
if (lne==0) lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Classes); // fall back
QCString title = lne ? lne->title() : theTranslator->trCompoundList();
bool addToIndex = lne==0 || lne->visible();
startFile(ol,"annotated",0,title,HLI_Annotated);
startTitle(ol,0);
ol.parseText(title);
endTitle(ol,0,0);
ol.startContents();
ol.startTextBlock();
ol.parseText(lne ? lne->intro() : theTranslator->trCompoundListDescription());
ol.endTextBlock();
// ---------------
// Linear class index for Latex/RTF
// ---------------
ol.pushGeneratorState();
ol.disable(OutputGenerator::Html);
Doxygen::indexList->disable();
writeAnnotatedClassList(ol);
Doxygen::indexList->enable();
ol.popGeneratorState();
// ---------------
// Hierarchical class index for HTML
// ---------------
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
{
if (addToIndex)
{
Doxygen::indexList->addContentsItem(TRUE,title,0,"annotated",0,TRUE,TRUE);
Doxygen::indexList->incContentsDepth();
}
FTVHelp* ftv = new FTVHelp(FALSE);
writeNamespaceTree(Doxygen::namespaceSDict,ftv,TRUE,TRUE,addToIndex);
writeClassTree(Doxygen::classSDict,ftv,addToIndex,TRUE);
QGString outStr;
FTextStream t(&outStr);
ftv->generateTreeViewInline(t);
ol.writeString(outStr);
delete ftv;
if (addToIndex)
{
Doxygen::indexList->decContentsDepth();
}
}
ol.popGeneratorState();
// ------
endFile(ol); // contains ol.endContents()
ol.popGeneratorState();
}
static void writeClassHierarchy ( OutputList &  ol,
FTVHelp *  ftv,
bool  addToIndex 
)
static

Definition at line 895 of file index.cpp.

References Doxygen::classSDict, IndexList::decContentsDepth(), OutputList::disable(), endIndexHierarchy(), Doxygen::hiddenClasses, OutputGenerator::Html, Doxygen::indexList, initClassHierarchy(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), and writeClassTreeForList().

Referenced by writeHierarchicalIndex().

{
initClassHierarchy(Doxygen::classSDict);
initClassHierarchy(Doxygen::hiddenClasses);
if (ftv)
{
ol.pushGeneratorState();
ol.disable(OutputGenerator::Html);
}
bool started=FALSE;
writeClassTreeForList(ol,Doxygen::classSDict,started,ftv,addToIndex);
writeClassTreeForList(ol,Doxygen::hiddenClasses,started,ftv,addToIndex);
if (started)
{
endIndexHierarchy(ol,0);
if (addToIndex)
{
Doxygen::indexList->decContentsDepth();
}
}
if (ftv)
{
ol.popGeneratorState();
}
}
static void writeClassLinkForMember ( OutputList &  ol,
MemberDef *  md,
const char *  separator,
QCString &  prevClassName 
)
static

Definition at line 2115 of file index.cpp.

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

Referenced by writeMemberList().

{
ClassDef *cd=md->getClassDef();
if ( cd && prevClassName!=cd->displayName())
{
ol.docify(separator);
ol.writeObjectLink(md->getReference(),md->getOutputFileBase(),md->anchor(),
cd->displayName());
ol.writeString("\n");
prevClassName = cd->displayName();
}
}
static void writeClassMemberIndex ( OutputList &  ol)
static

Definition at line 2639 of file index.cpp.

References IndexList::addContentsItem(), LayoutNavEntry::ClassMembers, CMHL_All, CMHL_Enums, CMHL_EnumValues, CMHL_Events, CMHL_Functions, CMHL_Properties, CMHL_Related, CMHL_Typedefs, CMHL_Variables, IndexList::decContentsDepth(), documentedClassMembers, LayoutNavEntry::find(), IndexList::incContentsDepth(), Doxygen::indexList, LayoutDocManager::instance(), LayoutDocManager::rootNavEntry(), theTranslator, LayoutNavEntry::title(), Translator::trCompoundMembers(), LayoutNavEntry::visible(), and writeClassMemberIndexFiltered().

Referenced by writeIndexHierarchyEntries().

{
LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassMembers);
bool addToIndex = lne==0 || lne->visible();
if (documentedClassMembers[CMHL_All]>0 && addToIndex)
{
Doxygen::indexList->addContentsItem(TRUE,lne ? lne->title() : theTranslator->trCompoundMembers(),0,"functions",0);
Doxygen::indexList->incContentsDepth();
}
writeClassMemberIndexFiltered(ol,CMHL_All);
writeClassMemberIndexFiltered(ol,CMHL_Functions);
writeClassMemberIndexFiltered(ol,CMHL_Variables);
writeClassMemberIndexFiltered(ol,CMHL_Typedefs);
writeClassMemberIndexFiltered(ol,CMHL_Enums);
writeClassMemberIndexFiltered(ol,CMHL_EnumValues);
writeClassMemberIndexFiltered(ol,CMHL_Properties);
writeClassMemberIndexFiltered(ol,CMHL_Events);
writeClassMemberIndexFiltered(ol,CMHL_Related);
if (documentedClassMembers[CMHL_All]>0 && addToIndex)
{
Doxygen::indexList->decContentsDepth();
}
}
static void writeClassMemberIndexFiltered ( OutputList &  ol,
ClassMemberHighlight  hl 
)
static

Definition at line 2520 of file index.cpp.

References IndexList::addContentsItem(), LayoutNavEntry::ClassMembers, CMHL_All, CMHL_Total, Config_getBool, SIntDict< T >::Iterator::current(), IndexList::decContentsDepth(), OutputList::disableAllBut(), documentedClassMembers, endFile(), endQuickIndexItem(), endQuickIndexList(), OutputList::endQuickIndices(), OutputList::endTextBlock(), LayoutNavEntry::find(), fixSpaces(), CmhlInfo::fname, getCmhlInfo(), HLI_Functions, OutputGenerator::Html, Doxygen::htmlFileExtension, IndexList::incContentsDepth(), Doxygen::indexList, LayoutDocManager::instance(), LayoutNavEntry::intro(), MemberIndexList::letter(), 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(), CmhlInfo::title, SIntDict< T >::Iterator::toFirst(), Translator::trCompoundMembers(), Translator::trCompoundMembersDescription(), DefinitionIntf::TypeClass, LayoutNavEntry::visible(), writeMemberList(), OutputList::writeQuickLinks(), writeQuickMemberIndex(), OutputList::writeSearchInfo(), OutputList::writeSplitBar(), and OutputList::writeString().

Referenced by writeClassMemberIndex().

{
if (documentedClassMembers[hl]==0) return;
static bool disableIndex = Config_getBool(DISABLE_INDEX);
bool multiPageIndex=FALSE;
if (documentedClassMembers[hl]>MAX_ITEMS_BEFORE_MULTIPAGE_INDEX)
{
multiPageIndex=TRUE;
}
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
QCString extension=Doxygen::htmlFileExtension;
LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassMembers);
QCString title = lne ? lne->title() : theTranslator->trCompoundMembers();
if (hl!=CMHL_All) title+=(QCString)" - "+getCmhlInfo(hl)->title;
bool addToIndex = lne==0 || lne->visible();
if (addToIndex)
{
Doxygen::indexList->addContentsItem(multiPageIndex,getCmhlInfo(hl)->title,0,
getCmhlInfo(hl)->fname,0,multiPageIndex,TRUE);
if (multiPageIndex) Doxygen::indexList->incContentsDepth();
}
bool first=TRUE;
SIntDict<MemberIndexList>::Iterator it(g_memberIndexLetterUsed[hl]);
MemberIndexList *ml;
for (it.toFirst();(ml=it.current());++it)
{
uint page = ml->letter();
QCString fileName = getCmhlInfo(hl)->fname;
if (multiPageIndex)
{
if (!first)
{
fileName+="_"+letterToLabel(page);
}
QCString cs = QString(QChar(page)).utf8();
if (addToIndex)
{
Doxygen::indexList->addContentsItem(FALSE,cs,0,fileName,0,FALSE,TRUE);
}
}
bool quickIndex = documentedClassMembers[hl]>maxItemsBeforeQuickIndex;
ol.startFile(fileName+extension,0,title);
ol.startQuickIndices();
if (!disableIndex)
{
ol.writeQuickLinks(TRUE,HLI_Functions,0);
#if 0
startQuickIndexList(ol);
// index item for global member list
startQuickIndexItem(ol,
getCmhlInfo(0)->fname+Doxygen::htmlFileExtension,hl==CMHL_All,TRUE,first);
ol.writeString(fixSpaces(getCmhlInfo(0)->title));
endQuickIndexItem(ol);
int i;
// index items per category member lists
for (i=1;i<CMHL_Total;i++)
{
if (documentedClassMembers[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,fileName.data(),getCmhlInfo(i)->fname,getCmhlInfo(i)->title.data());
endQuickIndexItem(ol);
}
}
endQuickIndexList(ol);
// quick alphabetical index
if (quickIndex)
{
writeQuickMemberIndex(ol,g_memberIndexLetterUsed[hl],page,
getCmhlInfo(hl)->fname,multiPageIndex);
}
#endif
}
ol.endQuickIndices();
ol.writeSplitBar(fileName);
ol.writeSearchInfo();
ol.startContents();
if (hl==CMHL_All)
{
ol.startTextBlock();
ol.parseText(lne ? lne->intro() : theTranslator->trCompoundMembersDescription(Config_getBool(EXTRACT_ALL)));
ol.endTextBlock();
}
else
{
// hack to work around a mozilla bug, which refuses to switch to
// normal lists otherwise
ol.writeString("&#160;");
}
writeMemberList(ol,quickIndex,
multiPageIndex?page:-1,
g_memberIndexLetterUsed[hl],
Definition::TypeClass);
endFile(ol);
first=FALSE;
}
if (multiPageIndex && addToIndex) Doxygen::indexList->decContentsDepth();
ol.popGeneratorState();
}
static void writeClassTree ( OutputList &  ol,
const BaseClassList *  bcl,
bool  hideSuper,
int  level,
FTVHelp *  ftv,
bool  addToIndex 
)
static

Generates HTML Help tree of classes

Definition at line 424 of file index.cpp.

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

Referenced by writeAnnotatedIndex(), writeClassTree(), writeClassTreeForList(), and writeNamespaceTree().

{
if (bcl==0) return;
BaseClassListIterator bcli(*bcl);
bool started=FALSE;
for ( ; bcli.current() ; ++bcli)
{
ClassDef *cd=bcli.current()->classDef;
if (cd->getLanguage()==SrcLangExt_VHDL && (VhdlDocGen::VhdlClasses)cd->protection()!=VhdlDocGen::ENTITYCLASS)
{
continue;
}
bool b;
if (cd->getLanguage()==SrcLangExt_VHDL)
{
b=hasVisibleRoot(cd->subClasses());
}
else
{
b=hasVisibleRoot(cd->baseClasses());
}
if (cd->isVisibleInHierarchy() && b) // hasVisibleRoot(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 = !cd->visited && !hideSuper && classHasVisibleChildren(cd);
//printf("tree4: Has children %s: %d\n",cd->name().data(),hasChildren);
if (cd->isLinkable())
{
//printf("Writing class %s\n",cd->displayName().data());
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,bcli.current()->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(0,0);
ol.parseText(cd->name());
ol.endIndexItem(0,0);
if (addToIndex)
{
Doxygen::indexList->addContentsItem(hasChildren,cd->displayName(),0,0,0);
}
if (ftv)
{
ftv->addContentsItem(hasChildren,cd->displayName(),0,0,0,FALSE,FALSE,cd);
}
}
if (hasChildren)
{
//printf("Class %s at %p visited=%d\n",cd->name().data(),cd,cd->visited);
bool wasVisited=cd->visited;
cd->visited=TRUE;
if (cd->getLanguage()==SrcLangExt_VHDL)
{
writeClassTree(ol,cd->baseClasses(),wasVisited,level+1,ftv,addToIndex);
}
else
{
writeClassTree(ol,cd->subClasses(),wasVisited,level+1,ftv,addToIndex);
}
}
ol.endIndexListItem();
}
}
if (started)
{
endIndexHierarchy(ol,level);
if (addToIndex)
{
Doxygen::indexList->decContentsDepth();
}
if (ftv)
{
ftv->decContentsDepth();
}
}
}
void writeClassTree ( ClassSDict *  clDict,
FTVHelp *  ftv,
bool  addToIndex,
bool  globalOnly 
)

Definition at line 1320 of file index.cpp.

References FTVHelp::addContentsItem(), addMembersToIndex(), ClassDef::anchor(), VhdlDocGen::ARCHITECTURECLASS, LayoutDocManager::Class, classVisibleInIndex(), FTVHelp::decContentsDepth(), DefinitionIntf::definitionType(), ClassDef::displayName(), ClassDef::getClassSDict(), Definition::getLanguage(), Definition::getOuterScope(), ClassDef::getOutputFileBase(), ClassDef::getReference(), Doxygen::globalScope, FTVHelp::incContentsDepth(), ClassDef::isSimple(), SDict< ClassDef >::Iterator, Definition::name(), VhdlDocGen::PACKAGECLASS, VhdlDocGen::PACKBODYCLASS, Definition::partOfGroups(), ClassDef::protection(), ClassDef::setClassName(), SrcLangExt_VHDL, ClassDef::templateMaster(), DefinitionIntf::TypeClass, and writeClassTree().

{
if (clDict)
{
ClassSDict::Iterator cli(*clDict);
ClassDef *cd;
for (;(cd=cli.current());++cli)
{
if (cd->getLanguage()==SrcLangExt_VHDL)
{
if ((VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::PACKAGECLASS ||
(VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::PACKBODYCLASS
)// no architecture
{
continue;
}
if ((VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::ARCHITECTURECLASS)
{
QCString n=cd->name();
cd->setClassName(n.data());
}
}
if (!globalOnly ||
cd->getOuterScope()==0 ||
cd->getOuterScope()==Doxygen::globalScope
)
{
int count=0;
if (cd->getClassSDict())
{
ClassSDict::Iterator ccit(*cd->getClassSDict());
ClassDef *ccd;
for (;(ccd=ccit.current());++ccit)
{
if (ccd->isLinkableInProject() && ccd->templateMaster()==0)
{
count++;
}
}
}
if (classVisibleInIndex(cd) && cd->templateMaster()==0)
{
ftv->addContentsItem(count>0,cd->displayName(FALSE),cd->getReference(),
cd->getOutputFileBase(),cd->anchor(),FALSE,TRUE,cd);
if (addToIndex &&
/*cd->partOfGroups()==0 &&*/
(cd->getOuterScope()==0 ||
cd->getOuterScope()->definitionType()!=Definition::TypeClass
)
)
{
addMembersToIndex(cd,LayoutDocManager::Class,
cd->displayName(FALSE),
cd->anchor(),
cd->partOfGroups()==0 && !cd->isSimple());
}
if (count>0)
{
ftv->incContentsDepth();
writeClassTree(cd->getClassSDict(),ftv,addToIndex,FALSE);
ftv->decContentsDepth();
}
}
}
}
}
}
static void writeClassTreeForList ( OutputList &  ol,
ClassSDict *  cl,
bool &  started,
FTVHelp *  ftv,
bool  addToIndex 
)
static

Definition at line 801 of file index.cpp.

References FTVHelp::addContentsItem(), IndexList::addContentsItem(), ClassDef::anchor(), ClassDef::baseClasses(), classHasVisibleChildren(), ClassDef::displayName(), OutputList::docify(), OutputList::endIndexItem(), OutputList::endIndexListItem(), OutputList::endTypewriter(), VhdlDocGen::ENTITYCLASS, Definition::getLanguage(), ClassDef::getOutputFileBase(), ClassDef::getReference(), hasVisibleRoot(), IndexList::incContentsDepth(), Doxygen::indexList, ClassDef::isLinkable(), ClassDef::isReference(), ClassDef::isVisibleInHierarchy(), SDict< ClassDef >::Iterator, OutputList::parseText(), ClassDef::protection(), SrcLangExt_VHDL, startIndexHierarchy(), OutputList::startIndexItem(), OutputList::startIndexListItem(), OutputList::startTypewriter(), ClassDef::subClasses(), ClassDef::visited, and writeClassTree().

Referenced by writeClassHierarchy().

{
ClassSDict::Iterator cli(*cl);
ClassDef *cd;
for (;(cd=cli.current());++cli)
{
//printf("class %s hasVisibleRoot=%d isVisibleInHierarchy=%d\n",
// cd->name().data(),
// hasVisibleRoot(cd->baseClasses()),
// cd->isVisibleInHierarchy()
// );
bool b;
if (cd->getLanguage()==SrcLangExt_VHDL)
{
if ((VhdlDocGen::VhdlClasses)cd->protection()!=VhdlDocGen::ENTITYCLASS)
{
continue;
}
b=!hasVisibleRoot(cd->subClasses());
}
else
{
b=!hasVisibleRoot(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 = !cd->visited && classHasVisibleChildren(cd);
//printf("list: Has children %s: %d\n",cd->name().data(),hasChildren);
if (cd->isLinkable())
{
//printf("Writing class %s isLinkable()=%d isLinkableInProject()=%d cd->templateMaster()=%p\n",
// cd->displayName().data(),cd->isLinkable(),cd->isLinkableInProject(),cd->templateMaster());
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);
}
}
else
{
ol.startIndexItem(0,0);
ol.parseText(cd->displayName());
ol.endIndexItem(0,0);
if (addToIndex)
{
Doxygen::indexList->addContentsItem(hasChildren,cd->displayName(),0,0,0,FALSE,FALSE);
}
if (ftv)
{
ftv->addContentsItem(hasChildren,cd->displayName(),0,0,0,FALSE,FALSE,cd);
}
}
if (cd->getLanguage()==SrcLangExt_VHDL && hasChildren)
{
writeClassTree(ol,cd->baseClasses(),cd->visited,1,ftv,addToIndex);
cd->visited=TRUE;
}
else if (hasChildren)
{
writeClassTree(ol,cd->subClasses(),cd->visited,1,ftv,addToIndex);
cd->visited=TRUE;
}
ol.endIndexListItem();
}
}
}
}
static void writeDirHierarchy ( OutputList &  ol,
FTVHelp *  ftv,
bool  addToIndex 
)
static

Definition at line 726 of file index.cpp.

References FTVHelp::addContentsItem(), IndexList::addContentsItem(), addMembersToIndex(), Config_getBool, convertToHtml(), Doxygen::directories, OutputList::disable(), FileDef::displayName(), doc, endIndexHierarchy(), LayoutDocManager::File, fileVisibleInIndex(), FileDef::getDirDef(), Definition::getOuterScope(), FileDef::getOutputFileBase(), Definition::getReference(), FileDef::getSourceFileBase(), Doxygen::globalScope, OutputGenerator::Html, Doxygen::indexList, Doxygen::inputNameList, FileDef::name(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), startIndexHierarchy(), and writeDirTreeNode().

Referenced by writeFileIndex().

{
if (ftv)
{
ol.pushGeneratorState();
ol.disable(OutputGenerator::Html);
}
static bool fullPathNames = Config_getBool(FULL_PATH_NAMES);
startIndexHierarchy(ol,0);
if (fullPathNames)
{
SDict<DirDef>::Iterator dli(*Doxygen::directories);
DirDef *dd;
for (dli.toFirst();(dd=dli.current());++dli)
{
if (dd->getOuterScope()==Doxygen::globalScope)
{
writeDirTreeNode(ol,dd,0,ftv,addToIndex);
}
}
}
if (ftv)
{
FileNameListIterator fnli(*Doxygen::inputNameList);
FileName *fn;
for (fnli.toFirst();(fn=fnli.current());++fnli)
{
FileNameIterator fni(*fn);
FileDef *fd;
for (;(fd=fni.current());++fni)
{
static bool fullPathNames = Config_getBool(FULL_PATH_NAMES);
if (!fullPathNames || fd->getDirDef()==0) // top level file
{
bool doc,src;
doc = fileVisibleInIndex(fd,src);
QCString reference, outputBase;
if (doc)
{
reference = fd->getReference();
outputBase = fd->getOutputFileBase();
}
if (doc || src)
{
ftv->addContentsItem(FALSE,fd->displayName(),
reference, outputBase, 0,
FALSE,FALSE,fd);
}
if (addToIndex)
{
if (doc)
{
addMembersToIndex(fd,LayoutDocManager::File,fd->displayName(),QCString(),TRUE);
}
else if (src)
{
Doxygen::indexList->addContentsItem(
FALSE, convertToHtml(fd->name(),TRUE), 0,
fd->getSourceFileBase(), 0, FALSE, TRUE, fd);
}
}
}
}
}
}
endIndexHierarchy(ol,0);
if (ftv)
{
ol.popGeneratorState();
}
}
static void writeDirTreeNode ( OutputList &  ol,
DirDef *  dd,
int  level,
FTVHelp *  ftv,
bool  addToIndex 
)
static

Definition at line 573 of file index.cpp.

References FTVHelp::addContentsItem(), IndexList::addContentsItem(), addMembersToIndex(), convertToHtml(), FTVHelp::decContentsDepth(), IndexList::decContentsDepth(), dirHasVisibleChildren(), FileDef::displayName(), doc, OutputList::docify(), endIndexHierarchy(), OutputList::endIndexItem(), OutputList::endIndexListItem(), OutputList::endTypewriter(), LayoutDocManager::File, fileVisibleInIndex(), Definition::getDefFileName(), Definition::getDefLine(), DirDef::getFiles(), DirDef::getOutputFileBase(), FileDef::getOutputFileBase(), Definition::getReference(), FileDef::getSourceFileBase(), FTVHelp::incContentsDepth(), IndexList::incContentsDepth(), Doxygen::indexList, Definition::isReference(), FileDef::name(), Definition::name(), OutputList::parseText(), DirDef::shortName(), startIndexHierarchy(), OutputList::startIndexItem(), OutputList::startIndexListItem(), OutputList::startTypewriter(), DirDef::subDirs(), and warn().

Referenced by writeDirHierarchy().

{
if (level>20)
{
warn(dd->getDefFileName(),dd->getDefLine(),
"maximum nesting level exceeded for directory %s: "
"check for possible recursive directory relation!\n",dd->name().data()
);
return;
}
if (!dirHasVisibleChildren(dd))
{
return;
}
static bool tocExpand = TRUE; //Config_getBool(TOC_EXPAND);
bool isDir = dd->subDirs().count()>0 || // there are subdirs
(tocExpand && // or toc expand and
dd->getFiles() && dd->getFiles()->count()>0 // there are files
);
//printf("gd=`%s': pageDict=%d\n",gd->name().data(),gd->pageDict->count());
if (addToIndex)
{
Doxygen::indexList->addContentsItem(isDir,dd->shortName(),dd->getReference(),dd->getOutputFileBase(),0,TRUE,TRUE);
Doxygen::indexList->incContentsDepth();
}
if (ftv)
{
ftv->addContentsItem(isDir,dd->shortName(),dd->getReference(),
dd->getOutputFileBase(),0,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().count()>0)
{
startIndexHierarchy(ol,level+1);
QListIterator<DirDef> dli(dd->subDirs());
DirDef *subdd = 0;
for (dli.toFirst();(subdd=dli.current());++dli)
{
writeDirTreeNode(ol,subdd,level+1,ftv,addToIndex);
}
endIndexHierarchy(ol,level+1);
}
FileList *fileList=dd->getFiles();
int fileCount=0;
if (fileList && fileList->count()>0)
{
QListIterator<FileDef> it(*fileList);
FileDef *fd;
for (;(fd=it.current());++it)
{
//static bool allExternals = Config_getBool(ALLEXTERNALS);
//if ((allExternals && fd->isLinkable()) || fd->isLinkableInProject())
//{
// fileCount++;
//}
bool genSourceFile;
if (fileVisibleInIndex(fd,genSourceFile))
{
fileCount++;
}
else if (genSourceFile)
{
fileCount++;
}
}
if (fileCount>0)
{
startIndexHierarchy(ol,level+1);
for (it.toFirst();(fd=it.current());++it)
{
bool doc,src;
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,
0,FALSE,FALSE,fd);
}
}
}
endIndexHierarchy(ol,level+1);
}
}
if (tocExpand && addToIndex)
{
// write files of this directory
if (fileCount>0)
{
QListIterator<FileDef> it(*fileList);
FileDef *fd;
for (;(fd=it.current());++it)
{
//static bool allExternals = Config_getBool(ALLEXTERNALS);
//if ((allExternals && fd->isLinkable()) || fd->isLinkableInProject())
bool doc,src;
doc = fileVisibleInIndex(fd,src);
if (doc)
{
addMembersToIndex(fd,LayoutDocManager::File,fd->displayName(),QCString(),TRUE);
}
else if (src)
{
Doxygen::indexList->addContentsItem(
FALSE, convertToHtml(fd->name(),TRUE), 0,
fd->getSourceFileBase(), 0, FALSE, TRUE, fd);
}
}
}
}
ol.endIndexListItem();
if (addToIndex)
{
Doxygen::indexList->decContentsDepth();
}
if (ftv)
{
ftv->decContentsDepth();
}
}
static void writeExampleIndex ( OutputList &  ol)
static

Definition at line 3005 of file index.cpp.

References IndexList::addContentsItem(), IndexList::decContentsDepth(), OutputList::disable(), endFile(), OutputList::endItemList(), OutputList::endItemListItem(), OutputList::endTextBlock(), endTitle(), LayoutNavEntry::Examples, Doxygen::exampleSDict, filterTitle(), LayoutNavEntry::find(), PageDef::getOutputFileBase(), Definition::getReference(), HLI_Examples, IndexList::incContentsDepth(), Doxygen::indexList, LayoutDocManager::instance(), LayoutNavEntry::intro(), SDict< PageDef >::Iterator, OutputGenerator::Man, Definition::name(), OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), startFile(), OutputList::startItemList(), OutputList::startItemListItem(), OutputList::startTextBlock(), startTitle(), theTranslator, PageDef::title(), LayoutNavEntry::title(), Translator::trExamples(), Translator::trExamplesDescription(), LayoutNavEntry::visible(), OutputList::writeObjectLink(), and OutputList::writeString().

Referenced by writeIndexHierarchyEntries().

{
if (Doxygen::exampleSDict->count()==0) return;
ol.pushGeneratorState();
ol.disable(OutputGenerator::Man);
LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Examples);
QCString title = lne ? lne->title() : theTranslator->trExamples();
bool addToIndex = lne==0 || lne->visible();
startFile(ol,"examples",0,title,HLI_Examples);
startTitle(ol,0);
ol.parseText(title);
endTitle(ol,0,0);
ol.startContents();
if (addToIndex)
{
Doxygen::indexList->addContentsItem(TRUE,title,0,"examples",0,TRUE,TRUE);
Doxygen::indexList->incContentsDepth();
}
ol.startTextBlock();
ol.parseText(lne ? lne->intro() : theTranslator->trExamplesDescription());
ol.endTextBlock();
ol.startItemList();
PageSDict::Iterator pdi(*Doxygen::exampleSDict);
PageDef *pd=0;
for (pdi.toFirst();(pd=pdi.current());++pdi)
{
ol.startItemListItem();
QCString n=pd->getOutputFileBase();
if (!pd->title().isEmpty())
{
ol.writeObjectLink(0,n,0,pd->title());
if (addToIndex)
{
Doxygen::indexList->addContentsItem(FALSE,filterTitle(pd->title()),pd->getReference(),n,0,FALSE,TRUE);
}
}
else
{
ol.writeObjectLink(0,n,0,pd->name());
if (addToIndex)
{
Doxygen::indexList->addContentsItem(FALSE,pd->name(),pd->getReference(),n,0,FALSE,TRUE);
}
}
ol.endItemListItem();
ol.writeString("\n");
}
ol.endItemList();
if (addToIndex)
{
Doxygen::indexList->decContentsDepth();
}
endFile(ol);
ol.popGeneratorState();
}
static void writeFileIndex ( OutputList &  ol)
static

Definition at line 1167 of file index.cpp.

References IndexList::addContentsItem(), Config_getBool, IndexList::decContentsDepth(), OutputList::disable(), OutputList::disableAllBut(), documentedFiles, documentedHtmlFiles, endFile(), OutputList::endIndexList(), OutputList::endTextBlock(), endTitle(), LayoutNavEntry::FileList, LayoutNavEntry::Files, LayoutNavEntry::find(), FTVHelp::generateTreeViewInline(), FileDef::getPath(), HLI_Files, OutputGenerator::Html, IndexList::incContentsDepth(), Doxygen::indexList, Doxygen::inputNameList, LayoutDocManager::instance(), LayoutNavEntry::intro(), OutputGenerator::Man, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), startFile(), OutputList::startIndexList(), OutputList::startTextBlock(), startTitle(), theTranslator, LayoutNavEntry::title(), Translator::trFileList(), Translator::trFileListDescription(), LayoutNavEntry::visible(), writeDirHierarchy(), writeSingleFileIndex(), and OutputList::writeString().

Referenced by writeIndexHierarchyEntries().

{
if (documentedHtmlFiles==0) return;
ol.pushGeneratorState();
ol.disable(OutputGenerator::Man);
if (documentedFiles==0) ol.disableAllBut(OutputGenerator::Html);
LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::FileList);
if (lne==0) lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Files); // fall back
QCString title = lne ? lne->title() : theTranslator->trFileList();
bool addToIndex = lne==0 || lne->visible();
startFile(ol,"files",0,title,HLI_Files);
startTitle(ol,0);
//if (!Config_getString(PROJECT_NAME).isEmpty())
//{
// title.prepend(Config_getString(PROJECT_NAME)+" ");
//}
ol.parseText(title);
endTitle(ol,0,0);
ol.startContents();
ol.startTextBlock();
if (addToIndex)
{
Doxygen::indexList->addContentsItem(TRUE,title,0,"files",0,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(OutputGenerator::Html);
OutputNameDict outputNameDict(1009);
OutputNameList outputNameList;
outputNameList.setAutoDelete(TRUE);
if (Config_getBool(FULL_PATH_NAMES))
{
// re-sort input files in (dir,file) output order instead of (file,dir) input order
FileNameListIterator fnli(*Doxygen::inputNameList);
FileName *fn;
for (fnli.toFirst();(fn=fnli.current());++fnli)
{
FileNameIterator fni(*fn);
FileDef *fd;
for (;(fd=fni.current());++fni)
{
QCString path=fd->getPath();
if (path.isEmpty()) path="[external]";
FileList *fl = outputNameDict.find(path);
if (fl)
{
fl->append(fd);
//printf("+ inserting %s---%s\n",fd->getPath().data(),fd->name().data());
}
else
{
//printf("o inserting %s---%s\n",fd->getPath().data(),fd->name().data());
fl = new FileList(path);
fl->append(fd);
outputNameList.append(fl);
outputNameDict.insert(path,fl);
}
}
}
}
ol.startIndexList();
if (Config_getBool(FULL_PATH_NAMES))
{
outputNameList.sort();
QListIterator<FileList> fnli(outputNameList);
FileList *fl;
for (fnli.toFirst();(fl=fnli.current());++fnli)
{
fl->sort();
QListIterator<FileDef> it(*fl);
FileDef *fd;
for (;(fd=it.current());++it)
{
writeSingleFileIndex(ol,fd);
}
}
}
else
{
FileNameListIterator fnli(*Doxygen::inputNameList);
FileName *fn;
for (fnli.toFirst();(fn=fnli.current());++fnli)
{
FileNameIterator fni(*fn);
FileDef *fd;
for (;(fd=fni.current());++fni)
{
writeSingleFileIndex(ol,fd);
}
}
}
ol.endIndexList();
// 1. }
ol.popGeneratorState();
// ---------------
// Hierarchical file index for HTML
// ---------------
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
FTVHelp* ftv = new FTVHelp(FALSE);
writeDirHierarchy(ol,ftv,addToIndex);
QGString outStr;
FTextStream t(&outStr);
ftv->generateTreeViewInline(t);
ol.writeString(outStr);
delete ftv;
ol.popGeneratorState();
// ------
if (addToIndex)
{
Doxygen::indexList->decContentsDepth();
}
endFile(ol);
ol.popGeneratorState();
}
static void writeFileLinkForMember ( OutputList &  ol,
MemberDef *  md,
const char *  separator,
QCString &  prevFileName 
)
static

Definition at line 2129 of file index.cpp.

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

Referenced by writeMemberList().

{
FileDef *fd=md->getFileDef();
if (fd && prevFileName!=fd->name())
{
ol.docify(separator);
ol.writeObjectLink(md->getReference(),md->getOutputFileBase(),md->anchor(),
fd->name());
ol.writeString("\n");
prevFileName = fd->name();
}
}
static void writeFileMemberIndex ( OutputList &  ol)
static

Definition at line 2809 of file index.cpp.

References IndexList::addContentsItem(), IndexList::decContentsDepth(), documentedFileMembers, LayoutNavEntry::FileGlobals, LayoutNavEntry::find(), FMHL_All, FMHL_Defines, FMHL_Enums, FMHL_EnumValues, FMHL_Functions, FMHL_Typedefs, FMHL_Variables, IndexList::incContentsDepth(), Doxygen::indexList, LayoutDocManager::instance(), LayoutDocManager::rootNavEntry(), theTranslator, LayoutNavEntry::title(), Translator::trFileMembers(), LayoutNavEntry::visible(), and writeFileMemberIndexFiltered().

Referenced by writeIndexHierarchyEntries().

{
LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::FileGlobals);
bool addToIndex = lne==0 || lne->visible();
if (documentedFileMembers[FMHL_All]>0 && addToIndex)
{
Doxygen::indexList->addContentsItem(FALSE,lne ? lne->title() : theTranslator->trFileMembers(),0,"globals",0);
Doxygen::indexList->incContentsDepth();
}
writeFileMemberIndexFiltered(ol,FMHL_All);
writeFileMemberIndexFiltered(ol,FMHL_Functions);
writeFileMemberIndexFiltered(ol,FMHL_Variables);
writeFileMemberIndexFiltered(ol,FMHL_Typedefs);
writeFileMemberIndexFiltered(ol,FMHL_Enums);
writeFileMemberIndexFiltered(ol,FMHL_EnumValues);
writeFileMemberIndexFiltered(ol,FMHL_Defines);
if (documentedFileMembers[FMHL_All]>0 && addToIndex)
{
Doxygen::indexList->decContentsDepth();
}
}
static void writeFileMemberIndexFiltered ( OutputList &  ol,
FileMemberHighlight  hl 
)
static

Definition at line 2695 of file index.cpp.

References IndexList::addContentsItem(), Config_getBool, SIntDict< T >::Iterator::current(), IndexList::decContentsDepth(), OutputList::disableAllBut(), documentedFileMembers, endFile(), endQuickIndexItem(), endQuickIndexList(), OutputList::endQuickIndices(), OutputList::endTextBlock(), LayoutNavEntry::FileGlobals, LayoutNavEntry::find(), fixSpaces(), FMHL_All, FMHL_Total, FmhlInfo::fname, getFmhlInfo(), HLI_Globals, OutputGenerator::Html, Doxygen::htmlFileExtension, IndexList::incContentsDepth(), Doxygen::indexList, LayoutDocManager::instance(), LayoutNavEntry::intro(), MemberIndexList::letter(), 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(), SIntDict< T >::Iterator::toFirst(), Translator::trFileMembers(), Translator::trFileMembersDescription(), DefinitionIntf::TypeFile, LayoutNavEntry::visible(), writeMemberList(), OutputList::writeQuickLinks(), writeQuickMemberIndex(), OutputList::writeSearchInfo(), OutputList::writeSplitBar(), and OutputList::writeString().

Referenced by writeFileMemberIndex().

{
if (documentedFileMembers[hl]==0) return;
static bool disableIndex = Config_getBool(DISABLE_INDEX);
bool multiPageIndex=FALSE;
if (documentedFileMembers[hl]>MAX_ITEMS_BEFORE_MULTIPAGE_INDEX)
{
multiPageIndex=TRUE;
}
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
QCString extension=Doxygen::htmlFileExtension;
LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::FileGlobals);
QCString title = lne ? lne->title() : theTranslator->trFileMembers();
bool addToIndex = lne==0 || lne->visible();
if (addToIndex)
{
Doxygen::indexList->addContentsItem(multiPageIndex,getFmhlInfo(hl)->title,0,
getFmhlInfo(hl)->fname,0,multiPageIndex,TRUE);
if (multiPageIndex) Doxygen::indexList->incContentsDepth();
}
bool first=TRUE;
SIntDict<MemberIndexList>::Iterator it(g_fileIndexLetterUsed[hl]);
MemberIndexList *ml;
for (it.toFirst();(ml=it.current());++it)
{
uint page = ml->letter();
QCString fileName = getFmhlInfo(hl)->fname;
if (multiPageIndex)
{
if (!first)
{
fileName+="_"+letterToLabel(page);
}
QCString cs = QString(QChar(page)).utf8();
if (addToIndex)
{
Doxygen::indexList->addContentsItem(FALSE,cs,0,fileName,0,FALSE,TRUE);
}
}
bool quickIndex = documentedFileMembers[hl]>maxItemsBeforeQuickIndex;
ol.startFile(fileName+extension,0,title);
ol.startQuickIndices();
if (!disableIndex)
{
ol.writeQuickLinks(TRUE,HLI_Globals,0);
#if 0
startQuickIndexList(ol);
// index item for all file member lists
startQuickIndexItem(ol,
getFmhlInfo(0)->fname+Doxygen::htmlFileExtension,hl==FMHL_All,TRUE,first);
ol.writeString(fixSpaces(getFmhlInfo(0)->title));
endQuickIndexItem(ol);
int i;
// index items for per category member lists
for (i=1;i<FMHL_Total;i++)
{
if (documentedFileMembers[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,g_fileIndexLetterUsed[hl],page,
getFmhlInfo(hl)->fname,multiPageIndex);
}
#endif
}
ol.endQuickIndices();
ol.writeSplitBar(fileName);
ol.writeSearchInfo();
ol.startContents();
if (hl==FMHL_All)
{
ol.startTextBlock();
ol.parseText(lne ? lne->intro() : theTranslator->trFileMembersDescription(Config_getBool(EXTRACT_ALL)));
ol.endTextBlock();
}
else
{
// hack to work around a mozilla bug, which refuses to switch to
// normal lists otherwise
ol.writeString("&#160;");
}
writeMemberList(ol,quickIndex,
multiPageIndex?page:-1,
g_fileIndexLetterUsed[hl],
Definition::TypeFile);
endFile(ol);
first=FALSE;
}
if (multiPageIndex && addToIndex) Doxygen::indexList->decContentsDepth();
ol.popGeneratorState();
}
static void writeGraphicalClassHierarchy ( OutputList &  ol)
static

Definition at line 1037 of file index.cpp.

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

Referenced by writeIndexHierarchyEntries().

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

Definition at line 3251 of file index.cpp.

References Config_getBool, Config_getString, OutputList::disableAllBut(), endFile(), endTitle(), OutputList::generateDoc(), generateGraphLegend(), getDotImageExtension(), OutputGenerator::Html, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), OutputList::startContents(), startFile(), startTitle(), theTranslator, Translator::trLegendDocs(), and Translator::trLegendTitle().

Referenced by generateOutput().

{
if (!Config_getBool(HAVE_DOT) || !Config_getBool(GENERATE_HTML)) return;
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
generateGraphLegend(Config_getString(HTML_OUTPUT));
bool &stripCommentsStateRef = Config_getBool(STRIP_CODE_COMMENTS);
bool oldStripCommentsState = stripCommentsStateRef;
bool &createSubdirs = Config_getBool(CREATE_SUBDIRS);
bool oldCreateSubdirs = createSubdirs;
// temporarily disable the stripping of comments for our own code example!
stripCommentsStateRef = FALSE;
// temporarily disable create subdirs for linking to our example
createSubdirs = FALSE;
startFile(ol,"graph_legend",0,theTranslator->trLegendTitle().data());
startTitle(ol,0);
ol.parseText(theTranslator->trLegendTitle());
endTitle(ol,0,0);
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 --]\n" + legendDocs.mid(e);
//printf("legendDocs=%s\n",legendDocs.data());
}
FileDef fd("","graph_legend");
ol.generateDoc("graph_legend",1,&fd,0,legendDocs,FALSE,FALSE);
// restore config settings
stripCommentsStateRef = oldStripCommentsState;
createSubdirs = oldCreateSubdirs;
endFile(ol);
ol.popGeneratorState();
}
static void writeGroupHierarchy ( OutputList &  ol,
FTVHelp *  ftv,
bool  addToIndex 
)
static

Definition at line 3545 of file index.cpp.

References OutputList::disable(), endIndexHierarchy(), Doxygen::groupSDict, OutputGenerator::Html, SDict< GroupDef >::Iterator, OutputList::popGeneratorState(), OutputList::pushGeneratorState(), startIndexHierarchy(), and writeGroupTreeNode().

Referenced by writeGroupIndex().

{
if (ftv)
{
ol.pushGeneratorState();
ol.disable(OutputGenerator::Html);
}
startIndexHierarchy(ol,0);
GroupSDict::Iterator gli(*Doxygen::groupSDict);
GroupDef *gd;
for (gli.toFirst();(gd=gli.current());++gli)
{
writeGroupTreeNode(ol,gd,0,ftv,addToIndex);
}
endIndexHierarchy(ol,0);
if (ftv)
{
ol.popGeneratorState();
}
}
static void writeGroupIndex ( OutputList &  ol)
static

Definition at line 3603 of file index.cpp.

References IndexList::addContentsItem(), IndexList::decContentsDepth(), OutputList::disable(), IndexList::disable(), OutputList::disableAllBut(), documentedGroups, IndexList::enable(), endFile(), OutputList::endTextBlock(), endTitle(), LayoutNavEntry::find(), FTVHelp::generateTreeViewInline(), HLI_Modules, OutputGenerator::Html, IndexList::incContentsDepth(), Doxygen::indexList, LayoutDocManager::instance(), LayoutNavEntry::intro(), OutputGenerator::Man, LayoutNavEntry::Modules, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), startFile(), OutputList::startTextBlock(), startTitle(), theTranslator, LayoutNavEntry::title(), Translator::trModules(), Translator::trModulesDescription(), LayoutNavEntry::visible(), writeGroupHierarchy(), and OutputList::writeString().

Referenced by writeIndexHierarchyEntries().

{
if (documentedGroups==0) return;
ol.pushGeneratorState();
// 1.{
ol.disable(OutputGenerator::Man);
LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Modules);
QCString title = lne ? lne->title() : theTranslator->trModules();
bool addToIndex = lne==0 || lne->visible();
startFile(ol,"modules",0,title,HLI_Modules);
startTitle(ol,0);
ol.parseText(title);
endTitle(ol,0,0);
ol.startContents();
ol.startTextBlock();
ol.parseText(lne ? lne->intro() : theTranslator->trModulesDescription());
ol.endTextBlock();
// ---------------
// Normal group index for Latex/RTF
// ---------------
// 2.{
ol.pushGeneratorState();
ol.disable(OutputGenerator::Html);
Doxygen::indexList->disable();
writeGroupHierarchy(ol,0,FALSE);
Doxygen::indexList->enable();
ol.popGeneratorState();
// 2.}
// ---------------
// interactive group index for HTML
// ---------------
// 2.{
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
{
if (addToIndex)
{
Doxygen::indexList->addContentsItem(TRUE,title,0,"modules",0,TRUE,TRUE);
Doxygen::indexList->incContentsDepth();
}
FTVHelp* ftv = new FTVHelp(FALSE);
writeGroupHierarchy(ol,ftv,addToIndex);
QGString outStr;
FTextStream t(&outStr);
ftv->generateTreeViewInline(t);
ol.disableAllBut(OutputGenerator::Html);
ol.writeString(outStr);
delete ftv;
if (addToIndex)
{
Doxygen::indexList->decContentsDepth();
}
}
ol.popGeneratorState();
// 2.}
endFile(ol);
ol.popGeneratorState();
// 1.}
}
static void writeGroupTreeNode ( OutputList &  ol,
GroupDef *  gd,
int  level,
FTVHelp *  ftv,
bool  addToIndex 
)
static

write groups as hierarchical trees

gd->visited &&

Definition at line 3298 of file index.cpp.

References FTVHelp::addContentsItem(), IndexList::addContentsItem(), addMembersToIndex(), MemberDef::anchor(), LayoutDocManager::Class, Config_getBool, convertToHtml(), MemberList::count(), SDict< T >::count(), FTVHelp::decContentsDepth(), IndexList::decContentsDepth(), OutputList::docify(), endIndexHierarchy(), OutputList::endIndexItem(), OutputList::endIndexListItem(), OutputList::endTypewriter(), MemberDef::enumFieldList(), GroupDef::getClasses(), Definition::getDefFileName(), Definition::getDefLine(), GroupDef::getDirs(), GroupDef::getFiles(), GroupDef::getMemberList(), GroupDef::getMemberLists(), GroupDef::getNamespaces(), GroupDef::getOutputFileBase(), MemberDef::getOutputFileBase(), GroupDef::getPages(), MemberDef::getReference(), Definition::getReference(), GroupDef::getSubGroups(), LayoutDocManager::Group, LayoutDocEntry::GroupClasses, LayoutDocEntry::GroupDirs, LayoutDocEntry::GroupFiles, LayoutDocEntry::GroupNamespaces, LayoutDocEntry::GroupNestedGroups, LayoutDocEntry::GroupPageDocs, GroupDef::groupTitle(), FTVHelp::incContentsDepth(), IndexList::incContentsDepth(), Doxygen::indexList, LayoutDocManager::instance(), GroupDef::isASubGroup(), MemberDef::isEnumerate(), Definition::isReference(), Definition::isVisible(), SDict< ClassDef >::Iterator, SDict< NamespaceDef >::Iterator, LayoutDocEntry::kind(), SectionInfo::label, LayoutDocEntry::MemberDef, MemberListType_documentationLists, Definition::name(), OutputList::parseText(), Doxygen::sectionDict, startIndexHierarchy(), OutputList::startIndexItem(), OutputList::startIndexListItem(), OutputList::startTypewriter(), LayoutDocEntryMemberDef::type, warn(), and writePages().

Referenced by writeGroupHierarchy().

{
//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 %s: check for possible recursive group relation!\n",gd->name().data()
);
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->isReference() || Config_getBool(EXTERNAL_GROUPS)) // hide external groups by default
)
{
//printf("gd->name()=%s #members=%d\n",gd->name().data(),gd->countMembers());
// write group info
bool hasSubGroups = gd->getSubGroups()->count()>0;
bool hasSubPages = gd->getPages()->count()>0;
int numSubItems = 0;
if (1 /*Config_getBool(TOC_EXPAND)*/)
{
QListIterator<MemberList> mli(gd->getMemberLists());
MemberList *ml;
for (mli.toFirst();(ml=mli.current());++mli)
{
if (ml->listType()&MemberListType_documentationLists)
{
numSubItems += ml->count();
}
}
numSubItems += gd->getNamespaces()->count();
numSubItems += gd->getClasses()->count();
numSubItems += gd->getFiles()->count();
numSubItems += gd->getDirs()->count();
numSubItems += gd->getPages()->count();
}
bool isDir = hasSubGroups || hasSubPages || numSubItems>0;
//printf("gd=`%s': pageDict=%d\n",gd->name().data(),gd->pageDict->count());
if (addToIndex)
{
Doxygen::indexList->addContentsItem(isDir,gd->groupTitle(),gd->getReference(),gd->getOutputFileBase(),0,isDir,TRUE);
Doxygen::indexList->incContentsDepth();
}
if (ftv)
{
ftv->addContentsItem(hasSubGroups,gd->groupTitle(),
gd->getReference(),gd->getOutputFileBase(),0,
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();
}
QListIterator<LayoutDocEntry> eli(LayoutDocManager::instance().docEntries(LayoutDocManager::Group));
LayoutDocEntry *lde;
for (eli.toFirst();(lde=eli.current());++eli)
{
if (lde->kind()==LayoutDocEntry::MemberDef && addToIndex)
{
LayoutDocEntryMemberDef *lmd = (LayoutDocEntryMemberDef*)lde;
MemberList *ml = gd->getMemberList(lmd->type);
if (ml)
{
MemberListIterator mi(*ml);
MemberDef *md;
for (mi.toFirst();(md=mi.current());++mi)
{
MemberList *enumList = md->enumFieldList();
bool isDir = enumList!=0 && md->isEnumerate();
if (md->isVisible() && md->name().find('@')==-1)
{
Doxygen::indexList->addContentsItem(isDir,
md->name(),md->getReference(),
md->getOutputFileBase(),md->anchor(),FALSE,addToIndex);
}
if (isDir)
{
Doxygen::indexList->incContentsDepth();
MemberListIterator emli(*enumList);
MemberDef *emd;
for (emli.toFirst();(emd=emli.current());++emli)
{
if (emd->isVisible())
{
Doxygen::indexList->addContentsItem(FALSE,
emd->name(),emd->getReference(),emd->getOutputFileBase(),
emd->anchor(),FALSE,addToIndex);
}
}
Doxygen::indexList->decContentsDepth();
}
}
}
}
else if (lde->kind()==LayoutDocEntry::GroupClasses && addToIndex)
{
ClassSDict::Iterator it(*gd->getClasses());
ClassDef *cd;
for (;(cd=it.current());++it)
{
//bool nestedClassInSameGroup =
// cd->getOuterScope() && cd->getOuterScope()->definitionType()==Definition::TypeClass &&
// cd->getOuterScope()->partOfGroups()!=0 && cd->getOuterScope()->partOfGroups()->contains(gd);
//printf("===== GroupClasses: %s visible=%d nestedClassInSameGroup=%d\n",cd->name().data(),cd->isVisible(),nestedClassInSameGroup);
if (cd->isVisible() /*&& !nestedClassInSameGroup*/)
{
//if (cd->isEmbeddedInOuterScope())
//{
//printf("add class & members %d\n",addToIndex);
addMembersToIndex(cd,LayoutDocManager::Class,cd->displayName(FALSE),cd->anchor(),addToIndex,TRUE);
//}
//else // only index the class, not its members
//{
// printf("%s: add class only\n",cd->name().data());
// Doxygen::indexList->addContentsItem(FALSE,
// cd->displayName(TRUE),cd->getReference(),
// cd->getOutputFileBase(),cd->anchor(),addToIndex,TRUE);
//}
}
}
}
else if (lde->kind()==LayoutDocEntry::GroupNamespaces && addToIndex)
{
NamespaceSDict::Iterator it(*gd->getNamespaces());
NamespaceDef *nd;
for (;(nd=it.current());++it)
{
if (nd->isVisible())
{
Doxygen::indexList->addContentsItem(FALSE,
nd->localName(),nd->getReference(),
nd->getOutputFileBase(),0,FALSE,FALSE);
}
}
}
else if (lde->kind()==LayoutDocEntry::GroupFiles && addToIndex)
{
QListIterator<FileDef> it(*gd->getFiles());
FileDef *fd;
for (;(fd=it.current());++it)
{
if (fd->isVisible())
{
Doxygen::indexList->addContentsItem(FALSE,
fd->displayName(),fd->getReference(),
fd->getOutputFileBase(),0,FALSE,FALSE);
}
}
}
else if (lde->kind()==LayoutDocEntry::GroupDirs && addToIndex)
{
QListIterator<DirDef> it(*gd->getDirs());
DirDef *dd;
for (;(dd=it.current());++it)
{
if (dd->isVisible())
{
Doxygen::indexList->addContentsItem(FALSE,
dd->shortName(),dd->getReference(),
dd->getOutputFileBase(),0,FALSE,FALSE);
}
}
}
else if (lde->kind()==LayoutDocEntry::GroupPageDocs && addToIndex)
{
SDict<PageDef>::Iterator it(*gd->getPages());
PageDef *pd;
for (;(pd=it.current());++it)
{
SectionInfo *si=0;
if (!pd->name().isEmpty()) si=Doxygen::sectionDict->find(pd->name());
bool hasSubPages = pd->hasSubPages();
bool hasSections = pd->hasSections();
Doxygen::indexList->addContentsItem(
hasSubPages || hasSections,
convertToHtml(pd->title(),TRUE),
gd->getReference(),
gd->getOutputFileBase(),
si ? si->label.data() : 0,
hasSubPages || hasSections,
TRUE); // addToNavIndex
if (hasSections || hasSubPages)
{
Doxygen::indexList->incContentsDepth();
}
if (hasSections)
{
pd->addSectionsToIndex();
}
writePages(pd,0);
if (hasSections || hasSubPages)
{
Doxygen::indexList->decContentsDepth();
}
}
}
else if (lde->kind()==LayoutDocEntry::GroupNestedGroups)
{
if (gd->getSubGroups()->count()>0)
{
startIndexHierarchy(ol,level+1);
QListIterator<GroupDef> gli(*gd->getSubGroups());
GroupDef *subgd = 0;
for (gli.toFirst();(subgd=gli.current());++gli)
{
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;
}
}
static void writeHierarchicalIndex ( OutputList &  ol)
static

Definition at line 956 of file index.cpp.

References IndexList::addContentsItem(), LayoutNavEntry::ClassHierarchy, Config_getBool, OutputList::disable(), IndexList::disable(), OutputList::disableAllBut(), OutputList::enable(), IndexList::enable(), endFile(), OutputList::endParagraph(), OutputList::endTextBlock(), OutputList::endTextLink(), endTitle(), LayoutNavEntry::find(), FTVHelp::generateTreeViewInline(), hierarchyClasses, HLI_Hierarchy, OutputGenerator::Html, Doxygen::indexList, LayoutDocManager::instance(), LayoutNavEntry::intro(), OutputGenerator::Latex, OutputGenerator::Man, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), OutputGenerator::RTF, OutputList::startContents(), startFile(), OutputList::startParagraph(), OutputList::startTextBlock(), OutputList::startTextLink(), startTitle(), theTranslator, LayoutNavEntry::title(), Translator::trClassHierarchy(), Translator::trClassHierarchyDescription(), Translator::trGotoGraphicalHierarchy(), LayoutNavEntry::visible(), writeClassHierarchy(), and OutputList::writeString().

Referenced by writeIndexHierarchyEntries().

{
if (hierarchyClasses==0) return;
ol.pushGeneratorState();
//1.{
ol.disable(OutputGenerator::Man);
LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassHierarchy);
QCString title = lne ? lne->title() : theTranslator->trClassHierarchy();
bool addToIndex = lne==0 || lne->visible();
startFile(ol,"hierarchy",0, title, HLI_Hierarchy);
startTitle(ol,0);
ol.parseText(title);
endTitle(ol,0,0);
ol.startContents();
ol.startTextBlock();
if (Config_getBool(HAVE_DOT) && Config_getBool(GRAPHICAL_HIERARCHY))
{
ol.disable(OutputGenerator::Latex);
ol.disable(OutputGenerator::RTF);
ol.startParagraph();
ol.startTextLink("inherits",0);
ol.parseText(theTranslator->trGotoGraphicalHierarchy());
ol.endTextLink();
ol.endParagraph();
ol.enable(OutputGenerator::Latex);
ol.enable(OutputGenerator::RTF);
}
ol.parseText(lne ? lne->intro() : theTranslator->trClassHierarchyDescription());
ol.endTextBlock();
// ---------------
// Static class hierarchy for Latex/RTF
// ---------------
ol.pushGeneratorState();
//2.{
ol.disable(OutputGenerator::Html);
Doxygen::indexList->disable();
writeClassHierarchy(ol,0,addToIndex);
Doxygen::indexList->enable();
ol.popGeneratorState();
//2.}
// ---------------
// Dynamic class hierarchical index for HTML
// ---------------
ol.pushGeneratorState();
//2.{
ol.disableAllBut(OutputGenerator::Html);
{
if (addToIndex)
{
Doxygen::indexList->addContentsItem(TRUE,title,0,"hierarchy",0,TRUE,TRUE);
}
FTVHelp* ftv = new FTVHelp(FALSE);
writeClassHierarchy(ol,ftv,addToIndex);
QGString outStr;
FTextStream t(&outStr);
ftv->generateTreeViewInline(t);
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
ol.writeString(outStr);
ol.popGeneratorState();
delete ftv;
}
ol.popGeneratorState();
//2.}
// ------
endFile(ol);
ol.popGeneratorState();
//1.}
}
static void writeIndex ( OutputList &  ol)
static

Definition at line 3767 of file index.cpp.

References IndexList::addContentsItem(), annotatedClassesPrinted, Config_getBool, Config_getString, OutputList::disable(), OutputList::disableAllBut(), Definition::docFile(), Definition::docLine(), documentedFiles, documentedGroups, documentedNamespaces, documentedPages, OutputList::enable(), endFile(), OutputList::endHeaderSection(), OutputList::endIndexSection(), OutputList::endProjectNumber(), OutputList::endQuickIndices(), OutputList::endTextBlock(), OutputList::endTitleHead(), Doxygen::exampleSDict, filterTitle(), OutputList::generateDoc(), PageDef::getGroupDef(), Definition::getOuterScope(), PageDef::getOutputFileBase(), PageDef::hasParentPage(), hierarchyClasses, HLI_Main, OutputGenerator::Html, Doxygen::indexList, Doxygen::insideMainPage, isClassDocumentation, isClassHierarchyIndex, isCompoundIndex, isEndIndex, isExampleDocumentation, isFileDocumentation, isFileIndex, isMainPage, isModuleDocumentation, isModuleIndex, isNamespaceDocumentation, isNamespaceIndex, isPageDocumentation, isPageDocumentation2, Definition::isReference(), isTitlePageAuthor, isTitlePageStart, SDict< PageDef >::Iterator, OutputList::lastIndexPage(), OutputGenerator::Latex, Doxygen::mainPage, mainPageHasTitle(), OutputGenerator::Man, Definition::name(), Doxygen::pageSDict, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), OutputGenerator::RTF, OutputList::startContents(), OutputList::startFile(), startFile(), OutputList::startHeaderSection(), OutputList::startIndexSection(), OutputList::startProjectNumber(), OutputList::startQuickIndices(), OutputList::startTextBlock(), OutputList::startTitleHead(), theTranslator, PageDef::title(), Translator::trClassDocumentation(), Translator::trCompoundIndex(), Translator::trCompoundIndexFortran(), VhdlDocGen::trDesignUnitIndex(), Translator::trDocumentation(), Translator::trExampleDocumentation(), Translator::trFileDocumentation(), Translator::trFileIndex(), Translator::trGeneratedBy(), Translator::trHierarchicalIndex(), Translator::trMainPage(), Translator::trModuleDocumentation(), Translator::trModuleIndex(), Translator::trModulesIndex(), Translator::trNamespaceDocumentation(), Translator::trNamespaceIndex(), Translator::trReferenceManual(), Translator::trTypeDocumentation(), OutputList::writeAnchor(), OutputList::writePageLink(), writePages(), OutputList::writeQuickLinks(), OutputList::writeSearchInfo(), OutputList::writeSplitBar(), and Definition::writeToc().

Referenced by writeIndexHierarchyEntries().

{
static bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
static bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
static QCString projectName = Config_getString(PROJECT_NAME);
// save old generator state
ol.pushGeneratorState();
QCString projPrefix;
if (!projectName.isEmpty())
{
projPrefix=projectName+" ";
}
//--------------------------------------------------------------------
// write HTML index
//--------------------------------------------------------------------
ol.disableAllBut(OutputGenerator::Html);
QCString defFileName =
Doxygen::mainPage ? Doxygen::mainPage->docFile().data() : "[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,0,title);
if (Doxygen::mainPage)
{
if (
(!projectName.isEmpty() && mainPageHasTitle() && qstricmp(title,projectName)!=0)
) // to avoid duplicate entries in the treeview
{
Doxygen::indexList->addContentsItem(Doxygen::mainPage->hasSubPages(),title,0,indexName,0,Doxygen::mainPage->hasSubPages(),TRUE);
}
if (Doxygen::mainPage->hasSubPages() || Doxygen::mainPage->hasSections())
{
writePages(Doxygen::mainPage,0);
}
}
ol.startQuickIndices();
if (!Config_getBool(DISABLE_INDEX))
{
ol.writeQuickLinks(TRUE,HLI_Main,0);
}
ol.endQuickIndices();
ol.writeSplitBar(indexName);
ol.writeSearchInfo();
bool headerWritten=FALSE;
if (Doxygen::mainPage && !Doxygen::mainPage->title().isEmpty())
{
if (Doxygen::mainPage->title().lower()!="notitle")
{
ol.startHeaderSection();
ol.startTitleHead(0);
ol.generateDoc(Doxygen::mainPage->docFile(),Doxygen::mainPage->docLine(),
Doxygen::mainPage,0,Doxygen::mainPage->title(),
TRUE,FALSE,0,TRUE,FALSE);
headerWritten = TRUE;
}
}
else
{
if (!projectName.isEmpty())
{
ol.startHeaderSection();
ol.startTitleHead(0);
ol.parseText(projPrefix+theTranslator->trDocumentation());
headerWritten = TRUE;
}
}
if (headerWritten)
{
ol.endTitleHead(0,0);
ol.endHeaderSection();
}
ol.startContents();
if (Config_getBool(DISABLE_INDEX) && Doxygen::mainPage==0)
{
ol.writeQuickLinks(FALSE,HLI_Main,0);
}
if (Doxygen::mainPage)
{
Doxygen::insideMainPage=TRUE;
if (Doxygen::mainPage->showToc() && Doxygen::mainPage->hasSections())
{
Doxygen::mainPage->writeToc(ol);
}
ol.startTextBlock();
ol.generateDoc(defFileName,defLine,Doxygen::mainPage,0,
Doxygen::mainPage->documentation(),TRUE,FALSE
/*,Doxygen::mainPage->sectionDict*/);
ol.endTextBlock();
Doxygen::insideMainPage=FALSE;
}
endFile(ol);
ol.disable(OutputGenerator::Html);
//--------------------------------------------------------------------
// write LaTeX/RTF index
//--------------------------------------------------------------------
ol.enable(OutputGenerator::Latex);
ol.enable(OutputGenerator::RTF);
ol.startFile("refman",0,0);
ol.startIndexSection(isTitlePageStart);
if (!Config_getString(LATEX_HEADER).isEmpty())
{
ol.disable(OutputGenerator::Latex);
}
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,0,Config_getString(PROJECT_NUMBER),FALSE,FALSE);
ol.endProjectNumber();
}
ol.endIndexSection(isTitlePageStart);
ol.startIndexSection(isTitlePageAuthor);
ol.parseText(theTranslator->trGeneratedBy());
ol.endIndexSection(isTitlePageAuthor);
ol.enable(OutputGenerator::Latex);
ol.lastIndexPage();
if (Doxygen::mainPage)
{
ol.startIndexSection(isMainPage);
if (mainPageHasTitle())
{
ol.parseText(Doxygen::mainPage->title());
}
else
{
ol.parseText(/*projPrefix+*/theTranslator->trMainPage());
}
ol.endIndexSection(isMainPage);
}
if (documentedPages>0)
{
//ol.parseText(projPrefix+theTranslator->trPageDocumentation());
//ol.endIndexSection(isPageDocumentation);
PageSDict::Iterator pdi(*Doxygen::pageSDict);
PageDef *pd=pdi.toFirst();
bool first=Doxygen::mainPage==0;
for (pdi.toFirst();(pd=pdi.current());++pdi)
{
if (!pd->getGroupDef() && !pd->isReference() &&
(!pd->hasParentPage() || // not inside other page
(Doxygen::mainPage==pd->getOuterScope())) // or inside main page
)
{
bool isCitationPage = pd->name()=="citelist";
if (isCitationPage)
{
// For LaTeX the bibliograph is already written by \bibliography
ol.pushGeneratorState();
ol.disable(OutputGenerator::Latex);
}
QCString title = pd->title();
if (title.isEmpty()) title=pd->name();
ol.startIndexSection(isPageDocumentation);
ol.parseText(title);
ol.endIndexSection(isPageDocumentation);
ol.pushGeneratorState(); // write TOC title (RTF only)
ol.disableAllBut(OutputGenerator::RTF);
ol.startIndexSection(isPageDocumentation2);
ol.parseText(title);
ol.endIndexSection(isPageDocumentation2);
ol.popGeneratorState();
ol.writeAnchor(0,pd->getOutputFileBase());
ol.writePageLink(pd->getOutputFileBase(),first);
first=FALSE;
if (isCitationPage)
{
ol.popGeneratorState();
}
}
}
}
if (!Config_getBool(LATEX_HIDE_INDICES))
{
//if (indexedPages>0)
//{
// ol.startIndexSection(isPageIndex);
// ol.parseText(/*projPrefix+*/ theTranslator->trPageIndex());
// ol.endIndexSection(isPageIndex);
//}
if (documentedGroups>0)
{
ol.startIndexSection(isModuleIndex);
ol.parseText(/*projPrefix+*/ theTranslator->trModuleIndex());
ol.endIndexSection(isModuleIndex);
}
if (documentedNamespaces>0)
{
ol.startIndexSection(isNamespaceIndex);
ol.parseText(/*projPrefix+*/(fortranOpt?theTranslator->trModulesIndex():theTranslator->trNamespaceIndex()));
ol.endIndexSection(isNamespaceIndex);
}
if (hierarchyClasses>0)
{
ol.startIndexSection(isClassHierarchyIndex);
ol.parseText(/*projPrefix+*/
(fortranOpt ? theTranslator->trCompoundIndexFortran() :
vhdlOpt ? VhdlDocGen::trDesignUnitIndex() :
theTranslator->trHierarchicalIndex()
));
ol.endIndexSection(isClassHierarchyIndex);
}
if (annotatedClassesPrinted>0)
{
ol.startIndexSection(isCompoundIndex);
ol.parseText(/*projPrefix+*/
(fortranOpt ? theTranslator->trCompoundIndexFortran() :
vhdlOpt ? VhdlDocGen::trDesignUnitIndex() :
theTranslator->trCompoundIndex()
));
ol.endIndexSection(isCompoundIndex);
}
if (documentedFiles>0)
{
ol.startIndexSection(isFileIndex);
ol.parseText(/*projPrefix+*/theTranslator->trFileIndex());
ol.endIndexSection(isFileIndex);
}
}
if (documentedGroups>0)
{
ol.startIndexSection(isModuleDocumentation);
ol.parseText(/*projPrefix+*/theTranslator->trModuleDocumentation());
ol.endIndexSection(isModuleDocumentation);
}
if (documentedNamespaces>0)
{
ol.startIndexSection(isNamespaceDocumentation);
ol.parseText(/*projPrefix+*/(fortranOpt?theTranslator->trModuleDocumentation():theTranslator->trNamespaceDocumentation()));
ol.endIndexSection(isNamespaceDocumentation);
}
if (annotatedClassesPrinted>0)
{
ol.startIndexSection(isClassDocumentation);
ol.parseText(/*projPrefix+*/(fortranOpt?theTranslator->trTypeDocumentation():theTranslator->trClassDocumentation()));
ol.endIndexSection(isClassDocumentation);
}
if (documentedFiles>0)
{
ol.startIndexSection(isFileDocumentation);
ol.parseText(/*projPrefix+*/theTranslator->trFileDocumentation());
ol.endIndexSection(isFileDocumentation);
}
if (Doxygen::exampleSDict->count()>0)
{
ol.startIndexSection(isExampleDocumentation);
ol.parseText(/*projPrefix+*/theTranslator->trExampleDocumentation());
ol.endIndexSection(isExampleDocumentation);
}
ol.endIndexSection(isEndIndex);
endFile(ol);
if (Doxygen::mainPage)
{
Doxygen::insideMainPage=TRUE;
ol.disable(OutputGenerator::Man);
startFile(ol,Doxygen::mainPage->name(),0,Doxygen::mainPage->title());
ol.startContents();
ol.startTextBlock();
ol.generateDoc(defFileName,defLine,Doxygen::mainPage,0,
Doxygen::mainPage->documentation(),FALSE,FALSE
);
ol.endTextBlock();
endFile(ol);
ol.enable(OutputGenerator::Man);
Doxygen::insideMainPage=FALSE;
}
ol.popGeneratorState();
}
void writeIndexHierarchy ( OutputList &  ol)

Definition at line 4442 of file index.cpp.

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

Referenced by generateOutput().

{
writeMenuData();
LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry();
if (lne)
{
writeIndexHierarchyEntries(ol,lne->children());
}
}
static void writeIndexHierarchyEntries ( OutputList &  ol,
const QList< LayoutNavEntry > &  entries 
)
static

Definition at line 4078 of file index.cpp.

References IndexList::addContentsItem(), annotatedClasses, LayoutNavEntry::baseFile(), LayoutNavEntry::children(), LayoutNavEntry::Classes, LayoutNavEntry::ClassHierarchy, LayoutNavEntry::ClassIndex, LayoutNavEntry::ClassList, LayoutNavEntry::ClassMembers, Config_getBool, correctURL(), IndexList::decContentsDepth(), documentedHtmlFiles, documentedNamespaces, LayoutNavEntry::Examples, LayoutNavEntry::FileGlobals, LayoutNavEntry::FileList, LayoutNavEntry::Files, IndexList::incContentsDepth(), Doxygen::indexList, LayoutDocManager::instance(), LayoutNavEntry::kind(), LayoutNavEntry::MainPage, LayoutNavEntry::Modules, msg(), LayoutNavEntry::NamespaceList, LayoutNavEntry::NamespaceMembers, LayoutNavEntry::Namespaces, LayoutNavEntry::Pages, LayoutNavEntry::title(), LayoutNavEntry::url(), LayoutNavEntry::User, LayoutNavEntry::UserGroup, LayoutNavEntry::visible(), writeAlphabeticalIndex(), writeAnnotatedIndex(), writeClassMemberIndex(), writeExampleIndex(), writeFileIndex(), writeFileMemberIndex(), writeGraphicalClassHierarchy(), writeGroupIndex(), writeHierarchicalIndex(), writeIndex(), writeNamespaceIndex(), writeNamespaceMemberIndex(), writePageIndex(), and writeUserGroupStubPage().

Referenced by writeIndexHierarchy().

{
QListIterator<LayoutNavEntry> li(entries);
LayoutNavEntry *lne;
for (li.toFirst();(lne=li.current());++li)
{
LayoutNavEntry::Kind kind = lne->kind();
uint index = (uint)kind;
if (index>=indexWritten.size())
{
uint i;
uint oldSize = indexWritten.size();
uint newSize = index+1;
indexWritten.resize(newSize);
for (i=oldSize;i<newSize;i++) indexWritten.at(i)=FALSE;
}
//printf("starting %s kind=%d\n",lne->title().data(),lne->kind());
bool addToIndex=lne->visible();
bool needsClosing=FALSE;
if (!indexWritten.at(index))
{
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::Modules:
msg("Generating module index...\n");
writeGroupIndex(ol);
break;
case LayoutNavEntry::Namespaces:
{
static bool showNamespaces = Config_getBool(SHOW_NAMESPACES);
if (showNamespaces)
{
if (documentedNamespaces>0 && addToIndex)
{
Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,0,0);
Doxygen::indexList->incContentsDepth();
needsClosing=TRUE;
}
if (LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Namespaces)!=lne) // for backward compatibility with old layout file
{
msg("Generating namespace index...\n");
writeNamespaceIndex(ol);
}
}
}
break;
case LayoutNavEntry::NamespaceList:
{
static 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 (annotatedClasses>0 && addToIndex)
{
Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,"annotated",0);
Doxygen::indexList->incContentsDepth();
needsClosing=TRUE;
}
if (LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Classes)!=lne) // for backward compatibility with old layout file
{
msg("Generating annotated compound index...\n");
writeAnnotatedIndex(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:
msg("Generating member index...\n");
writeClassMemberIndex(ol);
break;
case LayoutNavEntry::Files:
{
static bool showFiles = Config_getBool(SHOW_FILES);
if (showFiles)
{
if (documentedHtmlFiles>0 && addToIndex)
{
Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,0,0);
Doxygen::indexList->incContentsDepth();
needsClosing=TRUE;
}
if (LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Files)!=lne) // for backward compatibility with old layout file
{
msg("Generating file index...\n");
writeFileIndex(ol);
}
}
}
break;
case LayoutNavEntry::FileList:
{
static bool showFiles = Config_getBool(SHOW_FILES);
if (showFiles)
{
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:
{
// 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
}
bool isRef = lne->baseFile().left(4)=="@ref" || lne->baseFile().left(4)=="\\ref";
Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,url,0,FALSE,isRef || isRelative);
}
break;
case LayoutNavEntry::UserGroup:
if (addToIndex)
{
QCString url = correctURL(lne->url(),"!"); // add ! to relative URL
if (!url.isEmpty())
{
if (url=="![none]")
{
Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,0,0,FALSE,FALSE);
}
else
{
bool isRelative=url.at(0)=='!';
if (!isRelative) // absolute URL
{
url.prepend("^"); // prepend ^ to absolute URL
}
bool isRef = lne->baseFile().left(4)=="@ref" || lne->baseFile().left(4)=="\\ref";
Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,url,0,FALSE,isRef || isRelative);
}
}
else
{
Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,lne->baseFile(),0,TRUE,TRUE);
}
Doxygen::indexList->incContentsDepth();
needsClosing=TRUE;
}
writeUserGroupStubPage(ol,lne);
break;
}
if (kind!=LayoutNavEntry::User && kind!=LayoutNavEntry::UserGroup) // User entry may appear multiple times
{
indexWritten.at(index)=TRUE;
}
}
writeIndexHierarchyEntries(ol,lne->children());
if (needsClosing)
{
switch(kind)
{
case LayoutNavEntry::Namespaces:
case LayoutNavEntry::Classes:
case LayoutNavEntry::Files:
case LayoutNavEntry::UserGroup:
Doxygen::indexList->decContentsDepth();
break;
default:
break;
}
}
//printf("ending %s kind=%d\n",lne->title().data(),lne->kind());
}
}
static void writeMemberList ( OutputList &  ol,
bool  useSections,
int  page,
const LetterToIndexMap< MemberIndexList > &  memberLists,
DefinitionIntf::DefType  type 
)
static

Definition at line 2157 of file index.cpp.

References SIntDict< T >::Iterator::current(), getPrefixIndex(), MemberDef::isFunction(), MemberDef::isObjCMethod(), MemberDef::isSignal(), MemberDef::isSlot(), MemberIndexList::letter(), letterToLabel(), Definition::name(), SectionInfo::Subsection, SIntDict< T >::Iterator::toFirst(), SIntDict< T >::Iterator::toLast(), writeClassLinkForMember(), writeFileLinkForMember(), and writeNamespaceLinkForMember().

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

{
int index = (int)type;
ASSERT(index<3);
typedef void (*writeLinkForMember_t)(OutputList &ol,MemberDef *md,const char *separator,
QCString &prevNamespaceName);
// each index tab has its own write function
static writeLinkForMember_t writeLinkForMemberMap[3] =
{
&writeClassLinkForMember,
&writeFileLinkForMember,
&writeNamespaceLinkForMember
};
QCString prevName;
QCString prevDefName;
bool first=TRUE;
bool firstSection=TRUE;
bool firstItem=TRUE;
MemberIndexList *ml;
SIntDict<MemberIndexList>::Iterator it(memberLists);
for (it.toFirst();(ml=it.current());++it)
{
if (page!=-1)
{
ml = memberLists[page];
it.toLast();
}
if (ml==0 || ml->count()==0) continue;
ml->sort();
QListIterator<MemberDef> mli(*ml);
MemberDef *md;
for (mli.toFirst();(md=mli.current());++mli)
{
const char *sep;
bool isFunc=!md->isObjCMethod() &&
(md->isFunction() || md->isSlot() || md->isSignal());
QCString name=md->name();
int startIndex = getPrefixIndex(name);
if (QCString(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(ml->letter());
QCString cl = QString(QChar(ml->letter())).utf8();
QCString anchor=(QCString)"index_"+cs;
QCString title=(QCString)"- "+cl+" -";
ol.startSection(anchor,title,SectionInfo::Subsection);
ol.docify(title);
ol.endSection(anchor,SectionInfo::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 = ": ";
prevName = name.data()+startIndex;
}
else // same entry
{
sep = ", ";
// link to class for other members with the same name
}
if (index<3)
{
// write the link for the specific list type
writeLinkForMemberMap[index](ol,md,sep,prevDefName);
}
}
}
if (!firstItem) ol.endItemListItem();
ol.endItemList();
}
static void writeMenuData ( )
static

Definition at line 4426 of file index.cpp.

References Config_getBool, endl(), LayoutDocManager::instance(), renderQuickLinksAsJs(), and LayoutDocManager::rootNavEntry().

Referenced by writeIndexHierarchy().

{
if (!Config_getBool(GENERATE_HTML) || Config_getBool(DISABLE_INDEX)) return;
QCString outputDir = Config_getBool(HTML_OUTPUT);
QFile f(outputDir+"/menudata.js");
LayoutNavEntry *root = LayoutDocManager::instance().rootNavEntry();
if (f.open(IO_WriteOnly))
{
FTextStream t(&f);
t << "var menudata={";
bool hasChildren = renderQuickLinksAsJs(t,root,TRUE);
if (hasChildren) t << "]";
t << "}" << endl;
}
}
static void writeNamespaceIndex ( OutputList &  ol)
static

Definition at line 1448 of file index.cpp.

References IndexList::addContentsItem(), Definition::briefDescription(), Definition::briefFile(), Definition::briefLine(), Config_getBool, IndexList::decContentsDepth(), OutputList::disable(), OutputList::disableAllBut(), NamespaceDef::displayName(), documentedNamespaces, endFile(), OutputList::endIndexKey(), OutputList::endIndexList(), OutputList::endIndexValue(), OutputList::endTextBlock(), endTitle(), LayoutNavEntry::find(), OutputList::generateDoc(), FTVHelp::generateTreeViewInline(), Definition::getLanguage(), NamespaceDef::getOutputFileBase(), HLI_Namespaces, OutputGenerator::Html, IndexList::incContentsDepth(), Doxygen::indexList, LayoutDocManager::instance(), LayoutNavEntry::intro(), NamespaceDef::isLinkableInProject(), SDict< NamespaceDef >::Iterator, OutputGenerator::Man, LayoutNavEntry::NamespaceList, LayoutNavEntry::Namespaces, Doxygen::namespaceSDict, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), SrcLangExt_VHDL, OutputList::startContents(), startFile(), OutputList::startIndexKey(), OutputList::startIndexList(), OutputList::startIndexValue(), OutputList::startTextBlock(), startTitle(), theTranslator, LayoutNavEntry::title(), Translator::trNamespaceList(), Translator::trNamespaceListDescription(), LayoutNavEntry::visible(), writeNamespaceTree(), OutputList::writeObjectLink(), and OutputList::writeString().

Referenced by writeIndexHierarchyEntries().

{
if (documentedNamespaces==0) return;
ol.pushGeneratorState();
ol.disable(OutputGenerator::Man);
LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::NamespaceList);
if (lne==0) lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Namespaces); // fall back
QCString title = lne ? lne->title() : theTranslator->trNamespaceList();
bool addToIndex = lne==0 || lne->visible();
startFile(ol,"namespaces",0,title,HLI_Namespaces);
startTitle(ol,0);
ol.parseText(title);
endTitle(ol,0,0);
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(OutputGenerator::Html);
NamespaceSDict::Iterator nli(*Doxygen::namespaceSDict);
NamespaceDef *nd;
for (nli.toFirst();(nd=nli.current());++nli)
{
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(0, nd->getOutputFileBase().replace(0,qstrlen("namespace"),"class"),0,nd->displayName());
}
else
{
ol.writeObjectLink(0,nd->getOutputFileBase(),0,nd->displayName());
}
ol.endIndexKey();
bool hasBrief = !nd->briefDescription().isEmpty();
ol.startIndexValue(hasBrief);
if (hasBrief)
{
//ol.docify(" (");
ol.generateDoc(
nd->briefFile(),nd->briefLine(),
nd,0,
nd->briefDescription(TRUE),
FALSE, // index words
FALSE, // isExample
0, // example name
TRUE, // single line
TRUE // link from index
);
//ol.docify(")");
}
ol.endIndexValue(nd->getOutputFileBase(),hasBrief);
}
}
if (!first) ol.endIndexList();
ol.popGeneratorState();
// ---------------
// Hierarchical namespace index for HTML
// ---------------
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
{
if (addToIndex)
{
Doxygen::indexList->addContentsItem(TRUE,title,0,"namespaces",0,TRUE,TRUE);
Doxygen::indexList->incContentsDepth();
}
FTVHelp* ftv = new FTVHelp(FALSE);
writeNamespaceTree(Doxygen::namespaceSDict,ftv,TRUE,FALSE,addToIndex);
QGString outStr;
FTextStream t(&outStr);
ftv->generateTreeViewInline(t);
ol.writeString(outStr);
delete ftv;
if (addToIndex)
{
Doxygen::indexList->decContentsDepth();
}
}
ol.popGeneratorState();
// ------
endFile(ol);
ol.popGeneratorState();
}
static void writeNamespaceLinkForMember ( OutputList &  ol,
MemberDef *  md,
const char *  separator,
QCString &  prevNamespaceName 
)
static

Definition at line 2143 of file index.cpp.

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

Referenced by writeMemberList().

{
NamespaceDef *nd=md->getNamespaceDef();
if (nd && prevNamespaceName!=nd->displayName())
{
ol.docify(separator);
ol.writeObjectLink(md->getReference(),md->getOutputFileBase(),md->anchor(),
nd->displayName());
ol.writeString("\n");
prevNamespaceName = nd->displayName();
}
}
static void writeNamespaceMemberIndex ( OutputList &  ol)
static

Definition at line 2978 of file index.cpp.

References IndexList::addContentsItem(), IndexList::decContentsDepth(), documentedNamespaceMembers, LayoutNavEntry::find(), IndexList::incContentsDepth(), Doxygen::indexList, LayoutDocManager::instance(), LayoutNavEntry::NamespaceMembers, NMHL_All, NMHL_Enums, NMHL_EnumValues, NMHL_Functions, NMHL_Typedefs, NMHL_Variables, LayoutDocManager::rootNavEntry(), theTranslator, LayoutNavEntry::title(), Translator::trNamespaceMembers(), LayoutNavEntry::visible(), and writeNamespaceMemberIndexFiltered().

Referenced by writeIndexHierarchyEntries().

{
LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::NamespaceMembers);
bool addToIndex = lne==0 || lne->visible();
if (documentedNamespaceMembers[NMHL_All]>0 && addToIndex)
{
Doxygen::indexList->addContentsItem(FALSE,lne ? lne->title() : theTranslator->trNamespaceMembers(),0,"namespacemembers",0);
Doxygen::indexList->incContentsDepth();
}
//bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
writeNamespaceMemberIndexFiltered(ol,NMHL_All);
writeNamespaceMemberIndexFiltered(ol,NMHL_Functions);
writeNamespaceMemberIndexFiltered(ol,NMHL_Variables);
writeNamespaceMemberIndexFiltered(ol,NMHL_Typedefs);
writeNamespaceMemberIndexFiltered(ol,NMHL_Enums);
writeNamespaceMemberIndexFiltered(ol,NMHL_EnumValues);
if (documentedNamespaceMembers[NMHL_All]>0 && addToIndex)
{
Doxygen::indexList->decContentsDepth();
}
}
static void writeNamespaceMemberIndexFiltered ( OutputList &  ol,
NamespaceMemberHighlight  hl 
)
static

Definition at line 2863 of file index.cpp.

References IndexList::addContentsItem(), Config_getBool, SIntDict< T >::Iterator::current(), IndexList::decContentsDepth(), OutputList::disableAllBut(), documentedNamespaceMembers, endFile(), endQuickIndexItem(), endQuickIndexList(), OutputList::endQuickIndices(), OutputList::endTextBlock(), LayoutNavEntry::find(), fixSpaces(), NmhlInfo::fname, getNmhlInfo(), HLI_NamespaceMembers, OutputGenerator::Html, Doxygen::htmlFileExtension, IndexList::incContentsDepth(), Doxygen::indexList, LayoutDocManager::instance(), LayoutNavEntry::intro(), MemberIndexList::letter(), letterToLabel(), MAX_ITEMS_BEFORE_MULTIPAGE_INDEX, maxItemsBeforeQuickIndex, LayoutNavEntry::NamespaceMembers, NMHL_All, NMHL_Total, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), OutputList::startFile(), startQuickIndexItem(), startQuickIndexList(), OutputList::startQuickIndices(), OutputList::startTextBlock(), theTranslator, LayoutNavEntry::title(), SIntDict< T >::Iterator::toFirst(), Translator::trNamespaceMemberDescription(), Translator::trNamespaceMembers(), DefinitionIntf::TypeNamespace, LayoutNavEntry::visible(), writeMemberList(), OutputList::writeQuickLinks(), writeQuickMemberIndex(), OutputList::writeSearchInfo(), OutputList::writeSplitBar(), and OutputList::writeString().

Referenced by writeNamespaceMemberIndex().

{
if (documentedNamespaceMembers[hl]==0) return;
static bool disableIndex = Config_getBool(DISABLE_INDEX);
bool multiPageIndex=FALSE;
if (documentedNamespaceMembers[hl]>MAX_ITEMS_BEFORE_MULTIPAGE_INDEX)
{
multiPageIndex=TRUE;
}
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
QCString extension=Doxygen::htmlFileExtension;
LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::NamespaceMembers);
QCString title = lne ? lne->title() : theTranslator->trNamespaceMembers();
bool addToIndex = lne==0 || lne->visible();
if (addToIndex)
{
Doxygen::indexList->addContentsItem(multiPageIndex,getNmhlInfo(hl)->title,0,
getNmhlInfo(hl)->fname,0,multiPageIndex,TRUE);
if (multiPageIndex) Doxygen::indexList->incContentsDepth();
}
bool first=TRUE;
SIntDict<MemberIndexList>::Iterator it(g_namespaceIndexLetterUsed[hl]);
MemberIndexList *ml;
for (it.toFirst();(ml=it.current());++it)
{
uint page = ml->letter();
QCString fileName = getNmhlInfo(hl)->fname;
if (multiPageIndex)
{
if (!first)
{
fileName+="_"+letterToLabel(page);
}
QCString cs = QString(QChar(page)).utf8();
if (addToIndex)
{
Doxygen::indexList->addContentsItem(FALSE,cs,0,fileName,0,FALSE,TRUE);
}
}
bool quickIndex = documentedNamespaceMembers[hl]>maxItemsBeforeQuickIndex;
ol.startFile(fileName+extension,0,title);
ol.startQuickIndices();
if (!disableIndex)
{
ol.writeQuickLinks(TRUE,HLI_NamespaceMembers,0);
#if 0
startQuickIndexList(ol);
// index item for all namespace member lists
startQuickIndexItem(ol,
getNmhlInfo(0)->fname+Doxygen::htmlFileExtension,hl==NMHL_All,TRUE,first);
ol.writeString(fixSpaces(getNmhlInfo(0)->title));
endQuickIndexItem(ol);
int i;
// index items per category member lists
for (i=1;i<NMHL_Total;i++)
{
if (documentedNamespaceMembers[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,g_namespaceIndexLetterUsed[hl],page,
getNmhlInfo(hl)->fname,multiPageIndex);
}
#endif
}
ol.endQuickIndices();
ol.writeSplitBar(fileName);
ol.writeSearchInfo();
ol.startContents();
if (hl==NMHL_All)
{
ol.startTextBlock();
ol.parseText(lne ? lne->intro() : theTranslator->trNamespaceMemberDescription(Config_getBool(EXTRACT_ALL)));
ol.endTextBlock();
}
else
{
// hack to work around a mozilla bug, which refuses to switch to
// normal lists otherwise
ol.writeString("&#160;");
}
writeMemberList(ol,quickIndex,
multiPageIndex?page:-1,
g_namespaceIndexLetterUsed[hl],
Definition::TypeNamespace);
endFile(ol);
}
if (multiPageIndex && addToIndex) Doxygen::indexList->decContentsDepth();
ol.popGeneratorState();
}
static void writeNamespaceTree ( NamespaceSDict *  nsDict,
FTVHelp *  ftv,
bool  rootOnly,
bool  showClasses,
bool  addToIndex 
)
static

Definition at line 1389 of file index.cpp.

References FTVHelp::addContentsItem(), IndexList::addContentsItem(), FTVHelp::decContentsDepth(), IndexList::decContentsDepth(), NamespaceDef::getClassSDict(), Definition::getLanguage(), NamespaceDef::getNamespaceSDict(), Definition::getOuterScope(), NamespaceDef::getOutputFileBase(), Definition::getReference(), Doxygen::globalScope, FTVHelp::incContentsDepth(), IndexList::incContentsDepth(), Doxygen::indexList, NamespaceDef::isLinkableInProject(), SDict< NamespaceDef >::Iterator, NamespaceDef::localName(), namespaceHasVisibleChild(), SrcLangExt_VHDL, and writeClassTree().

Referenced by writeAnnotatedIndex(), and writeNamespaceIndex().

{
if (nsDict)
{
NamespaceSDict::Iterator nli(*nsDict);
NamespaceDef *nd;
for (nli.toFirst();(nd=nli.current());++nli)
{
if (nd->localName().find('@')==-1 &&
(!rootOnly || nd->getOuterScope()==Doxygen::globalScope))
{
bool hasChildren = namespaceHasVisibleChild(nd,showClasses);
bool isLinkable = nd->isLinkableInProject();
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 ((isLinkable && !showClasses) || hasChildren)
{
ftv->addContentsItem(hasChildren,nd->localName(),ref,file,0,FALSE,TRUE,nd);
if (addToIndex)
{
Doxygen::indexList->addContentsItem(hasChildren,nd->localName(),ref,file,QCString(),
hasChildren && !file.isEmpty(),addToIndex);
}
//printf("*** writeNamespaceTree count=%d addToIndex=%d showClasses=%d classCount=%d\n",
// count,addToIndex,showClasses,classCount);
if (hasChildren)
{
if (addToIndex) Doxygen::indexList->incContentsDepth();
ftv->incContentsDepth();
writeNamespaceTree(nd->getNamespaceSDict(),ftv,FALSE,showClasses,addToIndex);
if (showClasses)
{
writeClassTree(nd->getClassSDict(),ftv,addToIndex,FALSE);
}
ftv->decContentsDepth();
if (addToIndex) Doxygen::indexList->decContentsDepth();
}
}
}
}
}
}
static void writePageIndex ( OutputList &  ol)
static

Definition at line 3168 of file index.cpp.

References DefinitionIntf::definitionType(), OutputList::disableAllBut(), endFile(), OutputList::endTextBlock(), endTitle(), LayoutNavEntry::find(), FTVHelp::generateTreeViewInline(), Definition::getOuterScope(), HLI_Pages, OutputGenerator::Html, indexedPages, LayoutDocManager::instance(), LayoutNavEntry::intro(), Definition::isReference(), SDict< PageDef >::Iterator, LayoutNavEntry::Pages, Doxygen::pageSDict, OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), LayoutDocManager::rootNavEntry(), OutputList::startContents(), startFile(), OutputList::startTextBlock(), startTitle(), theTranslator, LayoutNavEntry::title(), Translator::trRelatedPages(), Translator::trRelatedPagesDescription(), DefinitionIntf::TypePage, writePages(), and OutputList::writeString().

Referenced by writeIndexHierarchyEntries().

{
if (indexedPages==0) return;
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Pages);
QCString title = lne ? lne->title() : theTranslator->trRelatedPages();
startFile(ol,"pages",0,title,HLI_Pages);
startTitle(ol,0);
ol.parseText(title);
endTitle(ol,0,0);
ol.startContents();
ol.startTextBlock();
ol.parseText(lne ? lne->intro() : theTranslator->trRelatedPagesDescription());
ol.endTextBlock();
{
FTVHelp* ftv = new FTVHelp(FALSE);
PageSDict::Iterator pdi(*Doxygen::pageSDict);
PageDef *pd=0;
for (pdi.toFirst();(pd=pdi.current());++pdi)
{
if ((pd->getOuterScope()==0 ||
pd->getOuterScope()->definitionType()!=Definition::TypePage) && // not a sub page
!pd->isReference() // not an external page
)
{
writePages(pd,ftv);
}
}
QGString outStr;
FTextStream t(&outStr);
ftv->generateTreeViewInline(t);
ol.writeString(outStr);
delete ftv;
}
// ol.popGeneratorState();
// ------
endFile(ol);
ol.popGeneratorState();
}
static void writePages ( PageDef *  pd,
FTVHelp *  ftv 
)
static

Definition at line 3102 of file index.cpp.

References FTVHelp::addContentsItem(), IndexList::addContentsItem(), Definition::addSectionsToIndex(), FTVHelp::decContentsDepth(), IndexList::decContentsDepth(), filterTitle(), LayoutNavEntry::find(), PageDef::getOutputFileBase(), Definition::getReference(), PageDef::getSubPages(), Definition::hasSections(), PageDef::hasSubPages(), FTVHelp::incContentsDepth(), IndexList::incContentsDepth(), Doxygen::indexList, LayoutDocManager::instance(), SDict< PageDef >::Iterator, Doxygen::mainPage, mainPageHasOwnTitle(), Definition::name(), LayoutNavEntry::Pages, LayoutDocManager::rootNavEntry(), PageDef::title(), LayoutNavEntry::visible(), and PageDef::visibleInIndex().

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

{
//printf("writePages()=%s pd=%p mainpage=%p\n",pd->name().data(),pd,Doxygen::mainPage);
LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Pages);
bool addToIndex = lne==0 || 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",pageTitle.data(),hasSubPages,hasSections);
ftv->addContentsItem(
hasSubPages,pageTitle,
pd->getReference(),pd->getOutputFileBase(),
0,hasSubPages,TRUE,pd);
}
if (addToIndex && pd!=Doxygen::mainPage)
{
Doxygen::indexList->addContentsItem(
hasSubPages || hasSections,pageTitle,
pd->getReference(),pd->getOutputFileBase(),
0,hasSubPages,TRUE);
}
}
if (hasSubPages && ftv) ftv->incContentsDepth();
bool doIndent = (hasSections || hasSubPages) &&
(pd!=Doxygen::mainPage || mainPageHasOwnTitle());
if (doIndent)
{
Doxygen::indexList->incContentsDepth();
}
if (hasSections)
{
pd->addSectionsToIndex();
}
PageSDict *subPages = pd->getSubPages();
if (subPages)
{
PageSDict::Iterator pi(*subPages);
PageDef *subPage;
for (pi.toFirst();(subPage=pi.current());++pi)
{
writePages(subPage,ftv);
}
}
if (hasSubPages && ftv) ftv->decContentsDepth();
if (doIndent)
{
Doxygen::indexList->decContentsDepth();
}
//printf("end writePages()=%s\n",pd->title().data());
}
static void writeQuickMemberIndex ( OutputList &  ol,
const LetterToIndexMap< MemberIndexList > &  charUsed,
uint  page,
QCString  fullName,
bool  multiPage 
)
static

Definition at line 2459 of file index.cpp.

References SIntDict< T >::Iterator::current(), endQuickIndexItem(), endQuickIndexList(), Doxygen::htmlFileExtension, MemberIndexList::letter(), letterToLabel(), startQuickIndexItem(), startQuickIndexList(), SIntDict< T >::Iterator::toFirst(), and OutputList::writeString().

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

{
bool first=TRUE;
startQuickIndexList(ol,TRUE);
SIntDict<MemberIndexList>::Iterator it(charUsed);
MemberIndexList *ml;
for (it.toFirst();(ml=it.current());++it)
{
uint i = ml->letter();
QCString is = letterToLabel(i);
QCString ci = QString(QChar(i)).utf8();
QCString anchor;
QCString extension=Doxygen::htmlFileExtension;
if (!multiPage)
anchor="#index_";
else if (first)
anchor=fullName+extension+"#index_";
else
anchor=fullName+"_"+letterToLabel(i)+extension+"#index_";
startQuickIndexItem(ol,anchor+is,i==page,TRUE,first);
ol.writeString(ci);
endQuickIndexItem(ol);
first=FALSE;
}
endQuickIndexList(ol);
}
static void writeSingleFileIndex ( OutputList &  ol,
FileDef *  fd 
)
static

Definition at line 1089 of file index.cpp.

References Definition::briefDescription(), Definition::briefFile(), Definition::briefLine(), Config_getBool, OutputList::disableAllBut(), doc, OutputList::docify(), OutputList::endBold(), OutputList::endIndexKey(), OutputList::endIndexValue(), OutputList::endTextLink(), OutputList::generateDoc(), FileDef::generateSourceFile(), FileDef::getOutputFileBase(), FileDef::getPath(), OutputGenerator::Html, FileDef::includeName(), FileDef::isDocumentationFile(), FileDef::isLinkableInProject(), Definition::isReference(), FileDef::name(), OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), OutputList::startBold(), OutputList::startIndexKey(), OutputList::startIndexValue(), OutputList::startTextLink(), stripFromPath(), theTranslator, Translator::trCode(), and OutputList::writeObjectLink().

Referenced by writeFileIndex().

{
//printf("Found filedef %s\n",fd->name().data());
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().copy());
}
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(0,fd->getOutputFileBase(),0,fd->name());
//if (addToIndex)
//{
// addMembersToIndex(fd,LayoutDocManager::File,fullName,QCString());
//}
}
else
{
ol.startBold();
ol.docify(fd->name());
ol.endBold();
//if (addToIndex)
//{
// Doxygen::indexList->addContentsItem(FALSE,fullName,0,0,0);
//}
}
if (src)
{
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
ol.docify(" ");
ol.startTextLink(fd->includeName(),0);
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,0,
fd->briefDescription(TRUE),
FALSE, // index words
FALSE, // isExample
0, // example name
TRUE, // single line
TRUE // link from index
);
//ol.docify(")");
}
ol.endIndexValue(fd->getOutputFileBase(),hasBrief);
//ol.popGeneratorState();
// --------------------------------------------------------
}
}
static void writeUserGroupStubPage ( OutputList &  ol,
LayoutNavEntry *  lne 
)
static

Definition at line 3728 of file index.cpp.

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

Referenced by writeIndexHierarchyEntries().

{
if (lne->baseFile().left(9)=="usergroup")
{
ol.pushGeneratorState();
ol.disableAllBut(OutputGenerator::Html);
startFile(ol,lne->baseFile(),0,lne->title(),HLI_UserGroup);
startTitle(ol,0);
ol.parseText(lne->title());
endTitle(ol,0,0);
ol.startContents();
QListIterator<LayoutNavEntry> li(lne->children());
LayoutNavEntry *entry;
int count=0;
for (li.toFirst();(entry=li.current());++li)
{
if (entry->visible()) count++;
}
if (count>0)
{
ol.writeString("<ul>\n");
for (li.toFirst();(entry=li.current());++li)
{
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();
}
}

Variable Documentation

int annotatedClasses

Definition at line 55 of file index.cpp.

Referenced by countDataStructures(), quickLinkVisible(), writeAlphabeticalClassList(), writeAlphabeticalIndex(), writeAnnotatedIndex(), and writeIndexHierarchyEntries().

int annotatedClassesPrinted

Definition at line 56 of file index.cpp.

Referenced by countDataStructures(), writeAnnotatedIndex(), and writeIndex().

int documentedClassMembers[CMHL_Total]

Definition at line 62 of file index.cpp.

Referenced by addClassMemberNameToIndex(), initClassMemberIndices(), quickLinkVisible(), renderQuickLinksAsJs(), writeClassMemberIndex(), and writeClassMemberIndexFiltered().

int documentedDirs

Definition at line 67 of file index.cpp.

Referenced by countDataStructures().

int documentedFileMembers[FMHL_Total]

Definition at line 63 of file index.cpp.

Referenced by addFileMemberNameToIndex(), initFileMemberIndices(), quickLinkVisible(), renderQuickLinksAsJs(), writeFileMemberIndex(), and writeFileMemberIndexFiltered().

int documentedFiles

Definition at line 58 of file index.cpp.

Referenced by countDataStructures(), writeFileIndex(), and writeIndex().

int documentedGroups

Definition at line 59 of file index.cpp.

Referenced by countDataStructures(), quickLinkVisible(), writeGroupIndex(), and writeIndex().

int documentedHtmlFiles

Definition at line 65 of file index.cpp.

Referenced by countDataStructures(), generateFileDocs(), quickLinkVisible(), writeFileIndex(), and writeIndexHierarchyEntries().

int documentedNamespaceMembers[NMHL_Total]

Definition at line 64 of file index.cpp.

Referenced by addNamespaceMemberNameToIndex(), initNamespaceMemberIndices(), quickLinkVisible(), renderQuickLinksAsJs(), writeNamespaceMemberIndex(), and writeNamespaceMemberIndexFiltered().

int documentedNamespaces

Definition at line 60 of file index.cpp.

Referenced by countDataStructures(), quickLinkVisible(), writeIndex(), writeIndexHierarchyEntries(), and writeNamespaceIndex().

int documentedPages

Definition at line 66 of file index.cpp.

Referenced by countDataStructures(), generatePageDocs(), and writeIndex().

LetterToIndexMap<MemberIndexList> g_fileIndexLetterUsed[FMHL_Total]
static

Definition at line 140 of file index.cpp.

LetterToIndexMap<MemberIndexList> g_memberIndexLetterUsed[CMHL_Total]
static

Definition at line 139 of file index.cpp.

LetterToIndexMap<MemberIndexList> g_namespaceIndexLetterUsed[NMHL_Total]
static

Definition at line 141 of file index.cpp.

int hierarchyClasses

Definition at line 57 of file index.cpp.

Referenced by countDataStructures(), quickLinkVisible(), writeGraphicalClassHierarchy(), writeHierarchicalIndex(), and writeIndex().

int indexedPages

Definition at line 61 of file index.cpp.

Referenced by countDataStructures(), quickLinkVisible(), and writePageIndex().

QArray<bool> indexWritten
static

Definition at line 4076 of file index.cpp.

const int maxItemsBeforeQuickIndex = MAX_ITEMS_BEFORE_QUICK_INDEX

Definition at line 143 of file index.cpp.

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