--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Orb/Doxygen/src/index.cpp Thu Jan 21 17:29:01 2010 +0000
@@ -0,0 +1,3829 @@
+/******************************************************************************
+ *
+ *
+ *
+ * Copyright (C) 1997-2008 by Dimitri van Heesch.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation under the terms of the GNU General Public License is hereby
+ * granted. No representations are made about the suitability of this software
+ * for any purpose. It is provided "as is" without express or implied warranty.
+ * See the GNU General Public License for more details.
+ *
+ * Documents produced by Doxygen are derivative works derived from the
+ * input used in their production; they are not affected by this license.
+ *
+ */
+
+/** @file
+ * @brief This file contains functions for the various index pages.
+ */
+
+#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"
+
+#define MAX_ITEMS_BEFORE_MULTIPAGE_INDEX 200
+#define MAX_ITEMS_BEFORE_QUICK_INDEX 30
+
+static const char search_styleSheet[] =
+#include "search_css.h"
+;
+
+static const char search_script[]=
+#include "search_js.h"
+;
+
+int annotatedClasses;
+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;
+
+int countClassHierarchy();
+int countClassMembers(int filter=CMHL_All);
+int countFileMembers(int filter=FMHL_All);
+void countFiles(int &htmlFiles,int &files);
+int countGroups();
+int countDirs();
+int countNamespaces();
+int countAnnotatedClasses();
+int countNamespaceMembers(int filter=NMHL_All);
+int countIncludeFiles();
+void countRelatedPages(int &docPages,int &indexPages);
+
+void countDataStructures()
+{
+ annotatedClasses = countAnnotatedClasses(); // "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 void startIndexHierarchy(OutputList &ol,int level)
+{
+ 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 endIndexHierarchy(OutputList &ol,int level)
+{
+ 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();
+}
+
+//----------------------------------------------------------------------------
+
+class MemberIndexList : public QList<MemberDef>
+{
+ public:
+ MemberIndexList() : QList<MemberDef>() {}
+ ~MemberIndexList() {}
+ int compareItems(GCI item1, GCI item2)
+ {
+ MemberDef *md1=(MemberDef *)item1;
+ MemberDef *md2=(MemberDef *)item2;
+ return stricmp(md1->name(),md2->name());
+ }
+};
+
+#define MEMBER_INDEX_ENTRIES 256
+
+static MemberIndexList g_memberIndexLetterUsed[CMHL_Total][MEMBER_INDEX_ENTRIES];
+static MemberIndexList g_fileIndexLetterUsed[FMHL_Total][MEMBER_INDEX_ENTRIES];
+static MemberIndexList g_namespaceIndexLetterUsed[NMHL_Total][MEMBER_INDEX_ENTRIES];
+
+static bool g_classIndexLetterUsed[CHL_Total][256];
+
+const int maxItemsBeforeQuickIndex = MAX_ITEMS_BEFORE_QUICK_INDEX;
+
+//----------------------------------------------------------------------------
+
+// strips w from s iff s starts with w
+bool stripWord(QCString &s,QCString w)
+{
+ bool success=FALSE;
+ if (s.left(w.length())==w)
+ {
+ success=TRUE;
+ s=s.right(s.length()-w.length());
+ }
+ return success;
+}
+
+//----------------------------------------------------------------------------
+// some quasi intelligent brief description abbreviator :^)
+QCString abbreviate(const char *s,const char *name)
+{
+ QCString scopelessName=name;
+ int i=scopelessName.findRev("::");
+ if (i!=-1) scopelessName=scopelessName.mid(i+2);
+ QCString result=s;
+ result=result.stripWhiteSpace();
+ // strip trailing .
+ if (!result.isEmpty() && result.at(result.length()-1)=='.')
+ result=result.left(result.length()-1);
+
+ // strip any predefined prefix
+ QStrList &briefDescAbbrev = Config_getList("ABBREVIATE_BRIEF");
+ const char *p = briefDescAbbrev.first();
+ while (p)
+ {
+ QCString s = p;
+ s.replace(QRegExp("\\$name"), scopelessName); // replace $name with entity name
+ s += " ";
+ stripWord(result,s);
+ p = briefDescAbbrev.next();
+ }
+
+ // capitalize first word
+ if (!result.isEmpty())
+ {
+ int c=result[0];
+ if (c>='a' && c<='z') c+='A'-'a';
+ result[0]=c;
+ }
+ return result;
+}
+
+//----------------------------------------------------------------------------
+
+static void startQuickIndexList(OutputList &ol)
+{
+ bool fancyTabs = TRUE;
+ if (fancyTabs)
+ {
+ ol.writeString(" <div class=\"tabs\">\n");
+ ol.writeString(" <ul>\n");
+ }
+ else
+ {
+ ol.writeString(" <div class=\"qindex\">");
+ }
+}
+
+static void endQuickIndexList(OutputList &ol)
+{
+ bool fancyTabs = TRUE;
+ if (fancyTabs)
+ {
+ ol.writeString(" </ul>\n");
+ }
+ ol.writeString(" </div>\n");
+}
+
+static void startQuickIndexItem(OutputList &ol,const char *l,
+ bool hl,bool compact,bool &first)
+{
+ 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 endQuickIndexItem(OutputList &ol)
+{
+ bool fancyTabs=TRUE;
+ if (fancyTabs) ol.writeString("</span>");
+ ol.writeString("</a>");
+ if (fancyTabs) ol.writeString("</li>\n");
+}
+
+
+static QCString fixSpaces(const QCString &s)
+{
+ return substitute(s," "," ");
+}
+
+
+void startTitle(OutputList &ol,const char *fileName)
+{
+ ol.startTitleHead(fileName);
+ ol.pushGeneratorState();
+ ol.disable(OutputGenerator::Man);
+}
+
+void endTitle(OutputList &ol,const char *fileName,const char *name)
+{
+ ol.popGeneratorState();
+ ol.endTitleHead(fileName,name);
+}
+
+void startFile(OutputList &ol,const char *name,const char *manName,
+ const char *title,HighlightedItem hli,bool additionalIndices)
+{
+ ol.startFile(name,manName,title);
+ if (!Config_getBool("DISABLE_INDEX"))
+ {
+ ol.startQuickIndices();
+ ol.writeQuickLinks(TRUE,hli);
+ if (!additionalIndices)
+ {
+ ol.endQuickIndices();
+ ol.startContents();
+ }
+ }
+ else
+ {
+ if (!additionalIndices)
+ {
+ ol.startContents();
+ }
+ }
+}
+
+void endFile(OutputList &ol,bool)
+{
+ ol.endContents();
+ ol.pushGeneratorState();
+ ol.disableAllBut(OutputGenerator::Html);
+ ol.writeFooter(); // write the footer
+ ol.popGeneratorState();
+ ol.endFile();
+}
+
+//----------------------------------------------------------------------------
+
+static bool classHasVisibleChildren(ClassDef *cd)
+{
+ if (cd->subClasses()==0) return FALSE;
+ BaseClassList *bcl=cd->subClasses();
+ BaseClassListIterator bcli(*bcl);
+ for ( ; bcli.current() ; ++bcli)
+ {
+ if (bcli.current()->classDef->isVisibleInHierarchy())
+ {
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+void writeClassTree(OutputList &ol,BaseClassList *bcl,bool hideSuper,int level,FTVHelp* ftv)
+{
+ if (bcl==0) return;
+ BaseClassListIterator bcli(*bcl);
+ bool started=FALSE;
+ for ( ; bcli.current() ; ++bcli)
+ {
+ ClassDef *cd=bcli.current()->classDef;
+ if (cd->isVisibleInHierarchy() && hasVisibleRoot(cd->baseClasses()))
+ {
+ if (!started)
+ {
+ startIndexHierarchy(ol,level);
+ 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();
+ }
+ Doxygen::indexList.addContentsItem(hasChildren,cd->displayName(),cd->getReference(),cd->getOutputFileBase(),0);
+ if (ftv)
+ ftv->addContentsItem(hasChildren,cd->displayName(),cd->getReference(),cd->getOutputFileBase(),0);
+ }
+ else
+ {
+ ol.startIndexItem(0,0);
+ ol.parseText(cd->name());
+ ol.endIndexItem(0,0);
+ Doxygen::indexList.addContentsItem(hasChildren,cd->displayName(),0,0,0);
+ if (ftv)
+ ftv->addContentsItem(hasChildren,cd->displayName(),0,0,0);
+ }
+ if (hasChildren)
+ {
+ //printf("Class %s at %p visited=%d\n",cd->name().data(),cd,cd->visited);
+ bool wasVisited=cd->visited;
+ cd->visited=TRUE;
+ writeClassTree(ol,cd->subClasses(),wasVisited,level+1,ftv);
+ }
+ ol.endIndexListItem();
+ }
+ }
+ if (started)
+ {
+ endIndexHierarchy(ol,level);
+ Doxygen::indexList.decContentsDepth();
+ if (ftv)
+ ftv->decContentsDepth();
+ }
+}
+
+
+//----------------------------------------------------------------------------
+/*! Generates HTML Help tree of classes */
+
+void writeClassTree(BaseClassList *cl,int level)
+{
+ if (cl==0) return;
+ BaseClassListIterator cli(*cl);
+ bool started=FALSE;
+ for ( ; cli.current() ; ++cli)
+ {
+ ClassDef *cd=cli.current()->classDef;
+ if (cd->isVisibleInHierarchy() && hasVisibleRoot(cd->baseClasses()))
+ //if (cd->isVisibleInHierarchy() && !cd->visited)
+ {
+ if (!started)
+ {
+ Doxygen::indexList.incContentsDepth();
+ started=TRUE;
+ }
+ bool hasChildren = !cd->visited && classHasVisibleChildren(cd);
+ //printf("tree2: Has children %s: %d\n",cd->name().data(),hasChildren);
+ if (cd->isLinkable())
+ {
+ Doxygen::indexList.addContentsItem(hasChildren,cd->displayName(),cd->getReference(),cd->getOutputFileBase(),0);
+ }
+ if (hasChildren)
+ {
+ writeClassTree(cd->subClasses(),level+1);
+ }
+ cd->visited=TRUE;
+ }
+ }
+ if (started)
+ {
+ Doxygen::indexList.decContentsDepth();
+ }
+}
+
+//----------------------------------------------------------------------------
+/*! Generates HTML Help tree of classes */
+
+void writeClassTreeNode(ClassDef *cd,bool &started,int level)
+{
+ //printf("writeClassTreeNode(%s) visited=%d\n",cd->name().data(),cd->visited);
+ if (cd->isVisibleInHierarchy() && !cd->visited)
+ {
+ if (!started)
+ {
+ started=TRUE;
+ }
+ bool hasChildren = classHasVisibleChildren(cd);
+ //printf("node: Has children %s: %d\n",cd->name().data(),hasChildren);
+ if (cd->isLinkable())
+ {
+ Doxygen::indexList.addContentsItem(hasChildren,cd->displayName(),cd->getReference(),cd->getOutputFileBase(),0);
+ }
+ if (hasChildren)
+ {
+ writeClassTree(cd->subClasses(),level+1);
+ }
+ cd->visited=TRUE;
+ }
+}
+
+void writeClassTree(ClassList *cl,int level)
+{
+ if (cl==0) return;
+ ClassListIterator cli(*cl);
+ bool started=FALSE;
+ for ( cli.toFirst() ; cli.current() ; ++cli)
+ {
+ cli.current()->visited=FALSE;
+ }
+ for ( cli.toFirst() ; cli.current() ; ++cli)
+ {
+ writeClassTreeNode(cli.current(),started,level);
+ }
+}
+
+void writeClassTree(ClassSDict *d,int level)
+{
+ if (d==0) return;
+ ClassSDict::Iterator cli(*d);
+ bool started=FALSE;
+ for ( cli.toFirst() ; cli.current() ; ++cli)
+ {
+ cli.current()->visited=FALSE;
+ }
+ for ( cli.toFirst() ; cli.current() ; ++cli)
+ {
+ writeClassTreeNode(cli.current(),started,level);
+ }
+}
+
+//----------------------------------------------------------------------------
+
+static void writeClassTreeForList(OutputList &ol,ClassSDict *cl,bool &started,FTVHelp* ftv)
+{
+ ClassSDict::Iterator cli(*cl);
+ for (;cli.current(); ++cli)
+ {
+ ClassDef *cd=cli.current();
+ //printf("class %s hasVisibleRoot=%d isVisibleInHierarchy=%d\n",
+ // cd->name().data(),
+ // hasVisibleRoot(cd->baseClasses()),
+ // cd->isVisibleInHierarchy()
+ // );
+ if (!hasVisibleRoot(cd->baseClasses())) // filter on root classes
+ {
+ if (cd->isVisibleInHierarchy()) // should it be visible
+ {
+ if (!started)
+ {
+ startIndexHierarchy(ol,0);
+ 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();
+ }
+ Doxygen::indexList.addContentsItem(hasChildren,cd->displayName(),cd->getReference(),cd->getOutputFileBase(),0);
+ if (ftv)
+ ftv->addContentsItem(hasChildren,cd->displayName(),cd->getReference(),cd->getOutputFileBase(),0);
+ }
+ else
+ {
+ ol.startIndexItem(0,0);
+ ol.parseText(cd->displayName());
+ ol.endIndexItem(0,0);
+ Doxygen::indexList.addContentsItem(hasChildren,cd->displayName(),0,0,0);
+ if (ftv)
+ ftv->addContentsItem(hasChildren,cd->displayName(),0,0,0);
+ }
+ if (hasChildren)
+ {
+ writeClassTree(ol,cd->subClasses(),cd->visited,1,ftv);
+ cd->visited=TRUE;
+ }
+ ol.endIndexListItem();
+ }
+ }
+ }
+}
+
+void writeClassHierarchy(OutputList &ol, FTVHelp* ftv)
+{
+ initClassHierarchy(Doxygen::classSDict);
+ initClassHierarchy(Doxygen::hiddenClasses);
+ if (ftv)
+ {
+ ol.pushGeneratorState();
+ ol.disable(OutputGenerator::Html);
+ }
+ bool started=FALSE;
+ writeClassTreeForList(ol,Doxygen::classSDict,started,ftv);
+ writeClassTreeForList(ol,Doxygen::hiddenClasses,started,ftv);
+ if (started)
+ {
+ endIndexHierarchy(ol,0);
+ Doxygen::indexList.decContentsDepth();
+ }
+ if (ftv)
+ ol.popGeneratorState();
+}
+
+//----------------------------------------------------------------------------
+
+static int countClassesInTreeList(const ClassSDict &cl)
+{
+ int count=0;
+ ClassSDict::Iterator cli(cl);
+ for (;cli.current(); ++cli)
+ {
+ ClassDef *cd=cli.current();
+ 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;
+}
+
+int countClassHierarchy()
+{
+ int count=0;
+ initClassHierarchy(Doxygen::classSDict);
+ initClassHierarchy(Doxygen::hiddenClasses);
+ count+=countClassesInTreeList(*Doxygen::classSDict);
+ count+=countClassesInTreeList(*Doxygen::hiddenClasses);
+ return count;
+}
+
+//----------------------------------------------------------------------------
+
+void writeHierarchicalIndex(OutputList &ol)
+{
+ bool vhdlOpt=Config_getBool("OPTIMIZE_OUTPUT_VHDL");
+ if (hierarchyClasses==0) return;
+ ol.pushGeneratorState();
+ ol.disable(OutputGenerator::Man);
+ startFile(ol,"hierarchy",0, theTranslator->trHierarchicalIndex().data(),
+ HLI_Hierarchy);
+ startTitle(ol,0);
+ QCString title = theTranslator->trClassHierarchy();
+ if (vhdlOpt) title = VhdlDocGen::trDesignUnitHierarchy();
+ //if (!Config_getString("PROJECT_NAME").isEmpty())
+ //{
+ // title.prepend(Config_getString("PROJECT_NAME")+" ");
+ //}
+ ol.parseText(title);
+ endTitle(ol,0,0);
+ ol.startTextBlock();
+ Doxygen::indexList.addContentsItem(TRUE,title,0,"hierarchy",0);
+ 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(theTranslator->trClassHierarchyDescription());
+ ol.endTextBlock();
+
+ FTVHelp* ftv = 0;
+ bool treeView=Config_getBool("USE_INLINE_TREES");
+ if (treeView)
+ ftv = new FTVHelp(false);
+
+ writeClassHierarchy(ol,ftv);
+
+ if (ftv)
+ {
+ QString OutStr;
+ ftv->generateTreeView(&OutStr);
+ ol.pushGeneratorState();
+ ol.disableAllBut(OutputGenerator::Html);
+ ol.writeString(OutStr);
+ ol.popGeneratorState();
+ delete ftv;
+ }
+ endFile(ol);
+ ol.popGeneratorState();
+}
+
+//----------------------------------------------------------------------------
+
+void writeGraphicalClassHierarchy(OutputList &ol)
+{
+ if (hierarchyClasses==0) return;
+ ol.disableAllBut(OutputGenerator::Html);
+ QCString title = theTranslator->trGraphicalHierarchy();
+ startFile(ol,"inherits",0,title.data(),HLI_Hierarchy);
+ startTitle(ol,0);
+ //if (!Config_getString("PROJECT_NAME").isEmpty())
+ //{
+ // title.prepend(Config_getString("PROJECT_NAME")+" ");
+ //}
+ ol.parseText(title);
+ endTitle(ol,0,0);
+ ol.startTextBlock();
+ Doxygen::indexList.addContentsItem(FALSE,theTranslator->trGraphicalHierarchy(),0,"inherits",0);
+ ol.startParagraph();
+ ol.startTextLink("hierarchy",0);
+ ol.parseText(theTranslator->trGotoTextualHierarchy());
+ ol.endTextLink();
+ ol.endParagraph();
+ //parseText(ol,theTranslator->trClassHierarchyDescription());
+ //ol.newParagraph();
+ ol.endTextBlock();
+ DotGfxHierarchyTable g;
+ ol.writeGraphicalHierarchy(g);
+ endFile(ol);
+ ol.enableAll();
+}
+
+//----------------------------------------------------------------------------
+
+void countFiles(int &htmlFiles,int &files)
+{
+ 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 = fd->isLinkableInProject();
+ bool src = fd->generateSourceFile();
+ bool nameOk = !fd->isDocumentationFile();
+ if (nameOk)
+ {
+ if (doc || src)
+ {
+ htmlFiles++;
+ }
+ if (doc)
+ {
+ files++;
+ }
+ }
+ }
+ }
+}
+
+//----------------------------------------------------------------------------
+
+void writeFileIndex(OutputList &ol)
+{
+ if (documentedHtmlFiles==0) return;
+ ol.pushGeneratorState();
+ ol.disable(OutputGenerator::Man);
+ if (documentedFiles==0) ol.disableAllBut(OutputGenerator::Html);
+ startFile(ol,"files",0,theTranslator->trFileIndex().data(),HLI_Files);
+ startTitle(ol,0);
+ QCString title = theTranslator->trFileList();
+ //if (!Config_getString("PROJECT_NAME").isEmpty())
+ //{
+ // title.prepend(Config_getString("PROJECT_NAME")+" ");
+ //}
+ ol.parseText(title);
+ endTitle(ol,0,0);
+ ol.startTextBlock();
+ Doxygen::indexList.addContentsItem(TRUE,theTranslator->trFileList(),0,"files",0);
+ Doxygen::indexList.incContentsDepth();
+ ol.parseText(theTranslator->trFileListDescription(Config_getBool("EXTRACT_ALL")));
+ ol.endTextBlock();
+
+ 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
+ FileName *fn=Doxygen::inputNameList->first();
+ while (fn)
+ {
+ FileDef *fd=fn->first();
+ while (fd)
+ {
+ QCString path=fd->getPath();
+ if (path.isEmpty()) path="[external]";
+ FileList *fl = outputNameDict.find(path);
+ if (fl)
+ {
+ fl->inSort(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->inSort(fd);
+ outputNameList.inSort(fl);
+ outputNameDict.insert(path,fl);
+ }
+ fd=fn->next();
+ }
+ fn=Doxygen::inputNameList->next();
+ }
+ }
+
+ ol.startIndexList();
+ FileList *fl=0;
+ if (Config_getBool("FULL_PATH_NAMES"))
+ {
+ fl = outputNameList.first();
+ }
+ else
+ {
+ fl = Doxygen::inputNameList->first();
+ }
+ while (fl)
+ {
+ FileDef *fd=fl->first();
+ while (fd)
+ {
+ //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());
+ Doxygen::indexList.addContentsItem(FALSE,fullName,fd->getReference(),fd->getOutputFileBase(),0);
+ }
+ else
+ {
+ ol.startBold();
+ ol.docify(fd->name());
+ ol.endBold();
+ 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.parseDoc(
+ fd->briefFile(),fd->briefLine(),
+ fd,0,
+ abbreviate(fd->briefDescription(),fd->name()),
+ FALSE, // index words
+ FALSE, // isExample
+ 0, // example name
+ TRUE, // single line
+ TRUE // link from index
+ );
+ //ol.docify(")");
+ }
+ ol.endIndexValue(fd->getOutputFileBase(),hasBrief);
+ //ol.popGeneratorState();
+ // --------------------------------------------------------
+ }
+ fd=fl->next();
+ }
+ if (Config_getBool("FULL_PATH_NAMES"))
+ {
+ fl=outputNameList.next();
+ }
+ else
+ {
+ fl=Doxygen::inputNameList->next();
+ }
+ }
+ ol.endIndexList();
+ Doxygen::indexList.decContentsDepth();
+ endFile(ol);
+ ol.popGeneratorState();
+}
+
+//----------------------------------------------------------------------------
+int countNamespaces()
+{
+ int count=0;
+ NamespaceSDict::Iterator nli(*Doxygen::namespaceSDict);
+ NamespaceDef *nd;
+ for (;(nd=nli.current());++nli)
+ {
+ if (nd->isLinkableInProject()) count++;
+ }
+ return count;
+}
+
+//----------------------------------------------------------------------------
+
+void writeNamespaceIndex(OutputList &ol)
+{
+ bool fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN");
+ if (documentedNamespaces==0) return;
+ ol.pushGeneratorState();
+ ol.disable(OutputGenerator::Man);
+ QCString title;
+ if (Config_getBool("OPTIMIZE_OUTPUT_JAVA"))
+ {
+ startFile(ol,"namespaces",0,theTranslator->trPackageList().data(),HLI_Namespaces);
+ title = theTranslator->trPackageList();
+ }
+ else if (fortranOpt)
+ {
+ startFile(ol,"namespaces",0,theTranslator->trModulesIndex().data(),HLI_Namespaces);
+ title = theTranslator->trModulesList();
+ }
+ else
+ {
+ startFile(ol,"namespaces",0,theTranslator->trNamespaceIndex().data(),HLI_Namespaces);
+ title = theTranslator->trNamespaceList();
+ }
+ startTitle(ol,0);
+ QCString longTitle = title;
+ //if (!Config_getString("PROJECT_NAME").isEmpty())
+ //{
+ // longTitle.prepend(Config_getString("PROJECT_NAME")+" ");
+ //}
+ ol.parseText(longTitle);
+ endTitle(ol,0,0);
+ ol.startTextBlock();
+ Doxygen::indexList.addContentsItem(TRUE,title,0,"namespaces",0);
+ Doxygen::indexList.incContentsDepth();
+ //ol.newParagraph();
+ if (Config_getBool("OPTIMIZE_OUTPUT_JAVA"))
+ {
+ ol.parseText(theTranslator->trPackageListDescription());
+ }
+ else if (fortranOpt)
+ {
+ ol.parseText(theTranslator->trModulesListDescription(Config_getBool("EXTRACT_ALL")));
+ }
+ else
+ {
+ ol.parseText(theTranslator->trNamespaceListDescription(Config_getBool("EXTRACT_ALL")));
+ }
+ //ol.newParagraph();
+ ol.endTextBlock();
+
+ bool first=TRUE;
+
+ 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();
+ ol.writeObjectLink(0,nd->getOutputFileBase(),0,nd->displayName());
+ ol.endIndexKey();
+ bool hasBrief = !nd->briefDescription().isEmpty();
+ ol.startIndexValue(hasBrief);
+ if (hasBrief)
+ {
+ //ol.docify(" (");
+ ol.parseDoc(
+ nd->briefFile(),nd->briefLine(),
+ nd,0,
+ abbreviate(nd->briefDescription(),nd->displayName()),
+ FALSE, // index words
+ FALSE, // isExample
+ 0, // example name
+ TRUE, // single line
+ TRUE // link from index
+ );
+ //ol.docify(")");
+ }
+ ol.endIndexValue(nd->getOutputFileBase(),hasBrief);
+ //ol.writeEndAnnoItem(nd->getOutputFileBase());
+ Doxygen::indexList.addContentsItem(FALSE,nd->displayName(),nd->getReference(),nd->getOutputFileBase(),0);
+ }
+ }
+ if (!first) ol.endIndexList();
+ Doxygen::indexList.decContentsDepth();
+ endFile(ol);
+ ol.popGeneratorState();
+}
+
+//----------------------------------------------------------------------------
+
+int countAnnotatedClasses()
+{
+ int count=0;
+ //ClassDef *cd=Doxygen::classList.first();
+ ClassSDict::Iterator cli(*Doxygen::classSDict);
+ ClassDef *cd;
+ for (;(cd=cli.current());++cli)
+ {
+ if (cd->isLinkableInProject() && cd->templateMaster()==0)
+ {
+ //printf("Annotated class %s\n",cd->name().data());
+ count++;
+ }
+ }
+ return count;
+}
+
+//----------------------------------------------------------------------
+
+void writeAnnotatedClassList(OutputList &ol)
+{
+ ol.startIndexList();
+ ClassSDict::Iterator cli(*Doxygen::classSDict);
+ ClassDef *cd;
+
+ // clear index
+ int x,y;
+ for (y=0;y<CHL_Total;y++)
+ {
+ for (x=0;x<256;x++)
+ {
+ g_classIndexLetterUsed[y][x]=FALSE;
+ }
+ }
+
+ // see which elements are in use
+ for (cli.toFirst();(cd=cli.current());++cli)
+ {
+ if (cd->isLinkableInProject() && cd->templateMaster()==0)
+ {
+ QCString dispName = cd->displayName();
+ int c = dispName.at(getPrefixIndex(dispName));
+ g_classIndexLetterUsed[CHL_All][c]=TRUE;
+ switch(cd->compoundType())
+ {
+ case ClassDef::Class:
+ g_classIndexLetterUsed[CHL_Classes][c]=TRUE;
+ break;
+ case ClassDef::Struct:
+ g_classIndexLetterUsed[CHL_Structs][c]=TRUE;
+ break;
+ case ClassDef::Union:
+ g_classIndexLetterUsed[CHL_Unions][c]=TRUE;
+ break;
+ case ClassDef::Interface:
+ g_classIndexLetterUsed[CHL_Interfaces][c]=TRUE;
+ break;
+ case ClassDef::Protocol:
+ g_classIndexLetterUsed[CHL_Protocols][c]=TRUE;
+ break;
+ case ClassDef::Category:
+ g_classIndexLetterUsed[CHL_Categories][c]=TRUE;
+ break;
+ case ClassDef::Exception:
+ g_classIndexLetterUsed[CHL_Exceptions][c]=TRUE;
+ break;
+
+ }
+ }
+ }
+
+ for (cli.toFirst();(cd=cli.current());++cli)
+ {
+ if (cd->isLinkableInProject() && cd->templateMaster()==0)
+ {
+ QCString type=cd->compoundTypeString();
+ ol.startIndexKey();
+ ol.writeObjectLink(0,cd->getOutputFileBase(),0,cd->displayName());
+ ol.endIndexKey();
+ bool hasBrief = !cd->briefDescription().isEmpty();
+ ol.startIndexValue(hasBrief);
+ if (hasBrief)
+ {
+ ol.parseDoc(
+ cd->briefFile(),cd->briefLine(),
+ cd,0,
+ abbreviate(cd->briefDescription(),cd->displayName()),
+ FALSE, // indexWords
+ FALSE, // isExample
+ 0, // example name
+ TRUE, // single line
+ TRUE // link from index
+ );
+ }
+ ol.endIndexValue(cd->getOutputFileBase(),hasBrief);
+ //ol.writeEndAnnoItem(cd->getOutputFileBase());
+ Doxygen::indexList.addContentsItem(FALSE,cd->displayName(),cd->getReference(),cd->getOutputFileBase(),0);
+ }
+ }
+ ol.endIndexList();
+}
+
+static QCString letterToLabel(char startLetter)
+{
+ QCString s(5);
+ if (isId(startLetter))
+ {
+ s[0]=startLetter; s[1]=0;
+ }
+ else
+ {
+ const char hex[]="0123456789abcdef";
+ s[0]='0';
+ s[1]='x';
+ s[2]=hex[startLetter>>4];
+ s[3]=hex[startLetter&0xF];
+ s[4]=0;
+ }
+ return s;
+}
+
+//----------------------------------------------------------------------------
+
+class PrefixIgnoreClassList : public ClassList
+{
+public:
+ virtual int compareItems(GCI item1, GCI item2)
+ {
+ ClassDef *c1=(ClassDef *)item1;
+ ClassDef *c2=(ClassDef *)item2;
+
+ QCString n1 = c1->className();
+ n1.remove (0, getPrefixIndex(n1));
+ QCString n2 = c2->className();
+ n2.remove (0, getPrefixIndex(n2));
+
+ return stricmp (n1, n2);
+ }
+};
+
+// write an alphabetical index of all class with a header for each letter
+void writeAlphabeticalClassList(OutputList &ol)
+{
+ //ol.startAlphabeticalIndexList();
+ // What starting letters are used
+ bool indexLetterUsed[256];
+ memset (indexLetterUsed, 0, sizeof (indexLetterUsed));
+
+ // 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)
+ {
+ int index = getPrefixIndex(cd->className());
+ //printf("name=%s index=%d\n",cd->className().data(),index);
+ startLetter=toupper(cd->className().at(index));
+ indexLetterUsed[startLetter] = true;
+ }
+ }
+
+ QCString alphaLinks = "<div class=\"qindex\">";
+ int l;
+ for (l = 0; l < 256; l++)
+ {
+ if (indexLetterUsed[l])
+ {
+ if (headerItems) alphaLinks += " | ";
+ headerItems++;
+ alphaLinks += (QCString)"<a class=\"qindex\" href=\"#letter_" +
+ (char)l + "\">" +
+ (char)l + "</a>";
+ }
+ }
+
+ alphaLinks += "</div>\n";
+ ol.writeString(alphaLinks);
+
+ ol.writeString("<table align=\"center\" width=\"95%\" border=\"0\" cellspacing=\"0\" cellpadding=\"0\">\n");
+
+ // the number of columns in the table
+ const int columns = Config_getInt("COLS_IN_ALPHA_INDEX");
+
+ int i,j;
+ int totalItems = headerItems + annotatedClasses; // number of items in the table
+ int rows = (totalItems + columns - 1)/columns; // number of rows in the table
+ int itemsInLastRow = (totalItems + columns -1)%columns + 1; // number of items in the last row
+
+ //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
+ PrefixIgnoreClassList classesByLetter[256];
+
+ // fill the columns with the class list (row elements in each column,
+ // expect for the columns with number >= itemsInLastRow, which get on
+ // item less.
+ //int icount=0;
+ startLetter=0;
+ for (cli.toFirst();(cd=cli.current());++cli)
+ {
+ if (cd->isLinkableInProject() && cd->templateMaster()==0)
+ {
+ int index = getPrefixIndex(cd->className());
+ startLetter=toupper(cd->className().at(index));
+ // Do some sorting again, since the classes are sorted by name with
+ // prefix, which should be ignored really.
+ classesByLetter[startLetter].inSort (cd);
+ }
+ }
+
+ // create one class list for each column
+ ClassList *colList = new ClassList[columns];
+
+ // fill the columns with the class list (row elements in each column,
+ // expect for the columns with number >= itemsInLastRow, which get on
+ // item less.
+ int col=0,row=0;
+ //int icount=0;
+ startLetter=0;
+ for (l = 0; l < 256; l++)
+ {
+ if (!indexLetterUsed[l]) continue;
+
+ // insert a new header using a dummy class pointer.
+ colList[col].append((ClassDef *)8); // insert dummy for the header
+ row++;
+ if ( row >= rows + ((col<itemsInLastRow) ? 0 : -1))
+ {
+ // if the header is the last item in the row, we add an extra
+ // row to make it easier to find the text of the header (this
+ // is then contained in the next cell)
+ colList[col].append(classesByLetter[l].at (0));
+ col++;
+ row=0;
+ }
+ uint i;
+ for (i = 0; i < classesByLetter[l].count(); i++)
+ {
+ // add the class definition to the correct column list
+ colList[col].append (classesByLetter[l].at (i));
+ row++;
+ if ( row >= rows + ((col<itemsInLastRow) ? 0 : -1)) { col++; row=0; }
+ }
+ }
+
+ // create iterators for each column
+ ClassListIterator **colIterators = new ClassListIterator*[columns];
+ for (i=0;i<columns;i++)
+ {
+ colIterators[i] = new ClassListIterator(colList[i]);
+ }
+
+ // generate table
+ for (i=0;i<rows;i++) // foreach table row
+ {
+ //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<colsInRow;j++) // foreach table column
+ {
+ ol.writeString("<td>");
+ ClassDef *cd = colIterators[j]->current();
+ //printf("columns [%d] cd=%p\n",j,cd);
+ if (cd==(ClassDef *)8) // the class pointer is really a header
+ {
+ cd=++(*colIterators[j]); // get the next item
+ if (cd)
+ {
+ //printf("head ClassDef=%p %s\n",cd,cd ? cd->name().data() : "<none>");
+ int index = getPrefixIndex(cd->className());
+ startLetter=toupper(cd->className().at(index));
+ QCString s = letterToLabel(startLetter);
+ //ol.writeIndexHeading(s);
+ 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\"> ");
+ ol.writeString(s);
+ ol.writeString( " </div>"
+ "</td>"
+ "</tr>"
+ "</table>\n");
+
+ }
+ }
+ else if (cd) // a real class, insert a link
+ {
+ QCString namesp,cname;
+ //if (cd->getNamespaceDef()) namesp=cd->getNamespaceDef()->displayName();
+ //QCString cname=cd->className();
+ extractNamespaceName(cd->name(),cname,namesp);
+ QCString nsDispName;
+ if (Config_getBool("OPTIMIZE_OUTPUT_JAVA"))
+ {
+ nsDispName=substitute(namesp,"::",".");
+ }
+ else
+ {
+ nsDispName=namesp.copy();
+ }
+
+ ol.writeObjectLink(cd->getReference(),
+ cd->getOutputFileBase(),0,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);
+ //printf("item ClassDef=%p %s\n",cd,cd ? cd->name().data() : "<none>");
+ ++(*colIterators[j]);
+ }
+ //ol.endTableColumn();
+ ol.writeString("</td>");
+ //if (j<colsInRow-1) ol.nextTableColumn();
+ }
+ //ol.endTableRow();
+ ol.writeString("</tr>");
+ }
+ //ol.endAlphabeticalIndexList();
+ ol.writeString("</table>");
+
+ ol.writeString(alphaLinks);
+
+ // release the temporary memory
+ for (i=0;i<columns;i++)
+ {
+ delete colIterators[i];
+ }
+ delete[] colIterators;
+ delete[] colList;
+}
+
+//----------------------------------------------------------------------------
+
+void writeAlphabeticalIndex(OutputList &ol)
+{
+ bool fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN");
+ bool vhdlOpt = Config_getBool("OPTIMIZE_OUTPUT_VHDL");
+ if (annotatedClasses==0) return;
+ ol.pushGeneratorState();
+ ol.disableAllBut(OutputGenerator::Html);
+ startFile(ol,"classes"+Doxygen::htmlFileExtension,0,theTranslator->trAlphabeticalList().data(),HLI_Classes);
+ startTitle(ol,0);
+ ol.parseText(/*Config_getString("PROJECT_NAME")+" "+*/
+ (fortranOpt ? theTranslator->trCompoundIndexFortran() :
+ vhdlOpt ? VhdlDocGen::trDesignUnitIndex() :
+ theTranslator->trCompoundIndex()
+ ));
+ endTitle(ol,0,0);
+ writeAlphabeticalClassList(ol);
+ endFile(ol);
+ ol.popGeneratorState();
+}
+
+//----------------------------------------------------------------------------
+
+void writeAnnotatedIndex(OutputList &ol)
+{
+ bool fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN");
+ bool vhdlOpt = Config_getBool("OPTIMIZE_OUTPUT_VHDL");
+ if (annotatedClasses==0) return;
+
+ ol.pushGeneratorState();
+ ol.disable(OutputGenerator::Man);
+ QCString title = fortranOpt ? theTranslator->trCompoundListFortran() :
+ vhdlOpt ? VhdlDocGen::trDesignUnitList() :
+ theTranslator->trCompoundList() ;
+ startFile(ol,"annotated",0,title.data(),HLI_Annotated);
+ startTitle(ol,0);
+ QCString longTitle = title;
+ //if (!Config_getString("PROJECT_NAME").isEmpty())
+ //{
+ // longTitle.prepend(Config_getString("PROJECT_NAME")+" ");
+ //}
+ ol.parseText(longTitle);
+ endTitle(ol,0,0);
+ ol.startTextBlock();
+ Doxygen::indexList.addContentsItem(TRUE,title,0,"annotated",0);
+ Doxygen::indexList.incContentsDepth();
+ QCString desc = fortranOpt ? theTranslator->trCompoundListDescriptionFortran() :
+ vhdlOpt ? VhdlDocGen::trDesignUnitListDescription() :
+ theTranslator->trCompoundListDescription() ;
+ ol.parseText(desc);
+ ol.endTextBlock();
+ writeAnnotatedClassList(ol);
+ Doxygen::indexList.decContentsDepth();
+
+ endFile(ol);
+ ol.popGeneratorState();
+}
+
+//----------------------------------------------------------------------------
+static void writeClassLinkForMember(OutputList &ol,MemberDef *md,const char *separator,
+ QCString &prevClassName)
+{
+ 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 writeFileLinkForMember(OutputList &ol,MemberDef *md,const char *separator,
+ QCString &prevFileName)
+{
+ 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 writeNamespaceLinkForMember(OutputList &ol,MemberDef *md,const char *separator,
+ QCString &prevNamespaceName)
+{
+ NamespaceDef *nd=md->getNamespaceDef();
+ if (nd && prevNamespaceName!=nd->name())
+ {
+ ol.docify(separator);
+ ol.writeObjectLink(md->getReference(),md->getOutputFileBase(),md->anchor(),
+ nd->name());
+ ol.writeString("\n");
+ prevNamespaceName = nd->name();
+ }
+}
+
+static void writeMemberList(OutputList &ol,bool useSections,int page,
+ MemberIndexList memberLists[MEMBER_INDEX_ENTRIES],
+ DefinitionIntf::DefType type)
+{
+ int pi;
+ // page==-1 => write all member indices to one page (used when total members is small)
+ // page!=-1 => write all member for this page only (used when total member is large)
+ int startIndex = page==-1 ? 0 : page;
+ int endIndex = page==-1 ? MEMBER_INDEX_ENTRIES-1 : page;
+ ASSERT((int)type<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;
+ for (pi=startIndex; pi<=endIndex; pi++) // page==-1 => pi=[0..127], page!=-1 => pi=page
+ {
+ MemberIndexList *ml = &memberLists[pi];
+ if (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();
+ char cl[2];
+ cl[0] = tolower(name.at(startIndex));
+ cl[1] = 0;
+ QCString cs = letterToLabel(cl[0]);
+ 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
+ }
+ // write the link for the specific list type
+ writeLinkForMemberMap[(int)type](ol,md,sep,prevDefName);
+ }
+ }
+ if (!firstItem) ol.endItemListItem();
+ ol.endItemList();
+}
+
+//----------------------------------------------------------------------------
+
+void initClassMemberIndices()
+{
+ int i=0;
+ int j=0;
+ for (j=0;j<CMHL_Total;j++)
+ {
+ documentedClassMembers[j]=0;
+ for (i=0;i<MEMBER_INDEX_ENTRIES;i++)
+ {
+ g_memberIndexLetterUsed[j][i].clear();
+ }
+ }
+}
+
+void addClassMemberNameToIndex(MemberDef *md)
+{
+ static bool hideFriendCompounds = Config_getBool("HIDE_FRIEND_COMPOUNDS");
+ static bool vhdlOpt = Config_getBool("OPTIMIZE_OUTPUT_VHDL");
+ ClassDef *cd=0;
+
+ if (vhdlOpt && (VhdlDocGen::isRecord(md) || VhdlDocGen::isUnit(md)))
+ {
+ VhdlDocGen::adjustRecordMember(md);
+ }
+
+ if (md->isLinkableInProject() &&
+ (cd=md->getClassDef()) &&
+ cd->isLinkableInProject() &&
+ cd->templateMaster()==0)
+ {
+ QCString n = md->name();
+ int index = getPrefixIndex(n);
+ uchar charCode = (uchar)n.at(index);
+ uint letter = charCode<128 ? tolower(charCode) : charCode;
+ 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))
+ {
+ g_memberIndexLetterUsed[CMHL_All][letter].append(md);
+ documentedClassMembers[CMHL_All]++;
+ }
+ if (md->isFunction() || md->isSlot() || md->isSignal())
+ {
+ g_memberIndexLetterUsed[CMHL_Functions][letter].append(md);
+ documentedClassMembers[CMHL_Functions]++;
+ }
+ else if (md->isVariable())
+ {
+ g_memberIndexLetterUsed[CMHL_Variables][letter].append(md);
+ documentedClassMembers[CMHL_Variables]++;
+ }
+ else if (md->isTypedef())
+ {
+ g_memberIndexLetterUsed[CMHL_Typedefs][letter].append(md);
+ documentedClassMembers[CMHL_Typedefs]++;
+ }
+ else if (md->isEnumerate())
+ {
+ g_memberIndexLetterUsed[CMHL_Enums][letter].append(md);
+ documentedClassMembers[CMHL_Enums]++;
+ }
+ else if (md->isEnumValue())
+ {
+ g_memberIndexLetterUsed[CMHL_EnumValues][letter].append(md);
+ documentedClassMembers[CMHL_EnumValues]++;
+ }
+ else if (md->isProperty())
+ {
+ g_memberIndexLetterUsed[CMHL_Properties][letter].append(md);
+ documentedClassMembers[CMHL_Properties]++;
+ }
+ else if (md->isEvent())
+ {
+ g_memberIndexLetterUsed[CMHL_Events][letter].append(md);
+ documentedClassMembers[CMHL_Events]++;
+ }
+ else if (md->isRelated() || md->isForeign() ||
+ (md->isFriend() && !isFriendToHide))
+ {
+ g_memberIndexLetterUsed[CMHL_Related][letter].append(md);
+ documentedClassMembers[CMHL_Related]++;
+ }
+ }
+ }
+}
+
+//----------------------------------------------------------------------------
+
+void initNamespaceMemberIndices()
+{
+ int i=0;
+ int j=0;
+ for (j=0;j<NMHL_Total;j++)
+ {
+ documentedNamespaceMembers[j]=0;
+ for (i=0;i<MEMBER_INDEX_ENTRIES;i++)
+ {
+ g_namespaceIndexLetterUsed[j][i].clear();
+ }
+ }
+}
+
+void addNamespaceMemberNameToIndex(MemberDef *md)
+{
+ NamespaceDef *nd=md->getNamespaceDef();
+ if (nd && nd->isLinkableInProject() && md->isLinkableInProject())
+ {
+ QCString n = md->name();
+ int index = getPrefixIndex(n);
+ uchar charCode = (uchar)n.at(index);
+ uint letter = charCode<128 ? tolower(charCode) : charCode;
+ if (!n.isEmpty())
+ {
+ g_namespaceIndexLetterUsed[NMHL_All][letter].append(md);
+ documentedNamespaceMembers[NMHL_All]++;
+
+ if (md->isFunction())
+ {
+ g_namespaceIndexLetterUsed[NMHL_Functions][letter].append(md);
+ documentedNamespaceMembers[NMHL_Functions]++;
+ }
+ else if (md->isVariable())
+ {
+ g_namespaceIndexLetterUsed[NMHL_Variables][letter].append(md);
+ documentedNamespaceMembers[NMHL_Variables]++;
+ }
+ else if (md->isTypedef())
+ {
+ g_namespaceIndexLetterUsed[NMHL_Typedefs][letter].append(md);
+ documentedNamespaceMembers[NMHL_Typedefs]++;
+ }
+ else if (md->isEnumerate())
+ {
+ g_namespaceIndexLetterUsed[NMHL_Enums][letter].append(md);
+ documentedNamespaceMembers[NMHL_Enums]++;
+ }
+ else if (md->isEnumValue())
+ {
+ g_namespaceIndexLetterUsed[NMHL_EnumValues][letter].append(md);
+ documentedNamespaceMembers[NMHL_EnumValues]++;
+ }
+ }
+ }
+}
+
+//----------------------------------------------------------------------------
+
+void initFileMemberIndices()
+{
+ int i=0;
+ int j=0;
+ for (j=0;j<NMHL_Total;j++)
+ {
+ documentedFileMembers[j]=0;
+ for (i=0;i<MEMBER_INDEX_ENTRIES;i++)
+ {
+ g_fileIndexLetterUsed[j][i].clear();
+ }
+ }
+}
+
+void addFileMemberNameToIndex(MemberDef *md)
+{
+ FileDef *fd=md->getFileDef();
+ if (fd && fd->isLinkableInProject() && md->isLinkableInProject())
+ {
+ QCString n = md->name();
+ int index = getPrefixIndex(n);
+ uchar charCode = (uchar)n.at(index);
+ uint letter = charCode<128 ? tolower(charCode) : charCode;
+ if (!n.isEmpty())
+ {
+ g_fileIndexLetterUsed[FMHL_All][letter].append(md);
+ documentedFileMembers[FMHL_All]++;
+
+ if (md->isFunction())
+ {
+ g_fileIndexLetterUsed[FMHL_Functions][letter].append(md);
+ documentedFileMembers[FMHL_Functions]++;
+ }
+ else if (md->isVariable())
+ {
+ g_fileIndexLetterUsed[FMHL_Variables][letter].append(md);
+ documentedFileMembers[FMHL_Variables]++;
+ }
+ else if (md->isTypedef())
+ {
+ g_fileIndexLetterUsed[FMHL_Typedefs][letter].append(md);
+ documentedFileMembers[FMHL_Typedefs]++;
+ }
+ else if (md->isEnumerate())
+ {
+ g_fileIndexLetterUsed[FMHL_Enums][letter].append(md);
+ documentedFileMembers[FMHL_Enums]++;
+ }
+ else if (md->isEnumValue())
+ {
+ g_fileIndexLetterUsed[FMHL_EnumValues][letter].append(md);
+ documentedFileMembers[FMHL_EnumValues]++;
+ }
+ else if (md->isDefine())
+ {
+ g_fileIndexLetterUsed[FMHL_Defines][letter].append(md);
+ documentedFileMembers[FMHL_Defines]++;
+ }
+ }
+ }
+}
+
+//----------------------------------------------------------------------------
+
+void writeQuickMemberIndex(OutputList &ol,
+ MemberIndexList charUsed[MEMBER_INDEX_ENTRIES],int page,
+ QCString fullName,bool multiPage)
+{
+ bool first=TRUE;
+ int i;
+ startQuickIndexList(ol);
+ for (i=33;i<127;i++)
+ {
+ char is[2];is[0]=(char)i;is[1]='\0';
+ if (charUsed[i].count()>0)
+ {
+ QCString anchor;
+ QCString extension=Doxygen::htmlFileExtension;
+ if (!multiPage)
+ anchor="#index_";
+ else if (first)
+ anchor=fullName+extension+"#index_";
+ else
+ anchor=fullName+QCString().sprintf("_0x%02x",i)+extension+"#index_";
+ startQuickIndexItem(ol,anchor+is,i==page,TRUE,first);
+ ol.writeString(is);
+ endQuickIndexItem(ol);
+ first=FALSE;
+ }
+ }
+ endQuickIndexList(ol);
+}
+
+//----------------------------------------------------------------------------
+
+static void writeClassMemberIndexFiltered(OutputList &ol, ClassMemberHighlight hl)
+{
+ if (documentedClassMembers[hl]==0) return;
+
+ static bool fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN");
+ static bool vhdlOpt = Config_getBool("OPTIMIZE_OUTPUT_VHDL");
+
+ bool multiPageIndex=FALSE;
+ int numPages=1;
+ if (documentedClassMembers[hl]>MAX_ITEMS_BEFORE_MULTIPAGE_INDEX)
+ {
+ multiPageIndex=TRUE;
+ numPages=127;
+ }
+
+ struct CmhlInfo
+ {
+ CmhlInfo(const char *fn,const char *t) : fname(fn), title(t) {}
+ const char *fname;
+ QCString title;
+ } 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())
+ };
+
+ ol.pushGeneratorState();
+ ol.disableAllBut(OutputGenerator::Html);
+
+ QCString extension=Doxygen::htmlFileExtension;
+ QCString title = fortranOpt ? theTranslator->trCompoundMembersFortran() :
+ vhdlOpt ? VhdlDocGen::trDesignUnitMembers() :
+ theTranslator->trCompoundMembers() ;
+ if (hl!=CMHL_All) title+=(QCString)" - "+cmhlInfo[hl].title;
+
+ int page;
+ bool first=TRUE;
+ for (page=0;page<numPages;page++)
+ {
+ if (!multiPageIndex || g_memberIndexLetterUsed[hl][page].count()>0)
+ {
+ QCString fileName = cmhlInfo[hl].fname;
+ if (multiPageIndex && !first)
+ {
+ fileName+=QCString().sprintf("_0x%02x",page);
+ }
+
+ startFile(ol,fileName+extension,0,title,HLI_Functions,TRUE);
+
+ startQuickIndexList(ol);
+
+ // index item for global member list
+ startQuickIndexItem(ol,
+ cmhlInfo[0].fname+Doxygen::htmlFileExtension,hl==CMHL_All,TRUE,first);
+ ol.writeString(fixSpaces(cmhlInfo[0].title));
+ endQuickIndexItem(ol);
+
+ // index items per category member lists
+ int i;
+ for (i=1;i<CMHL_Total;i++)
+ {
+ if (documentedClassMembers[i]>0)
+ {
+ startQuickIndexItem(ol,cmhlInfo[i].fname+Doxygen::htmlFileExtension,hl==i,TRUE,first);
+ ol.writeString(fixSpaces(cmhlInfo[i].title));
+ //printf("multiPageIndex=%d first=%d fileName=%s file=%s title=%s\n",
+ // multiPageIndex,first,fileName.data(),cmhlInfo[i].fname,cmhlInfo[i].title.data());
+ endQuickIndexItem(ol);
+ }
+ }
+
+ endQuickIndexList(ol);
+
+ // quick alphabetical index
+ bool quickIndex = documentedClassMembers[hl]>maxItemsBeforeQuickIndex;
+ if (quickIndex)
+ {
+ writeQuickMemberIndex(ol,g_memberIndexLetterUsed[hl],page,
+ cmhlInfo[hl].fname,multiPageIndex);
+ }
+
+ ol.endQuickIndices();
+ ol.startContents();
+
+ if (hl==CMHL_All)
+ {
+ static bool extractAll = Config_getBool("EXTRACT_ALL");
+ ol.parseText(fortranOpt ? theTranslator->trCompoundMembersDescriptionFortran(extractAll) :
+ theTranslator->trCompoundMembersDescription(extractAll));
+ }
+ else
+ {
+ // hack to work around a mozilla bug, which refuses to switch to
+ // normal lists otherwise
+ ol.writeString(" ");
+ }
+ //ol.newParagraph(); // FIXME:PARA
+ writeMemberList(ol,quickIndex,
+ multiPageIndex?page:-1,
+ g_memberIndexLetterUsed[hl],
+ Definition::TypeClass);
+ endFile(ol);
+ first=FALSE;
+ }
+ }
+
+ ol.popGeneratorState();
+}
+
+void writeClassMemberIndex(OutputList &ol)
+{
+ bool fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN");
+ 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)
+ {
+ QCString title = fortranOpt?theTranslator->trCompoundMembersFortran():theTranslator->trCompoundMembers();
+ Doxygen::indexList.addContentsItem(FALSE,title,0,"functions",0);
+ }
+}
+
+//----------------------------------------------------------------------------
+
+static void writeFileMemberIndexFiltered(OutputList &ol, FileMemberHighlight hl)
+{
+ if (documentedFileMembers[hl]==0) return;
+
+ bool fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN");
+ bool vhdlOpt = Config_getBool("OPTIMIZE_OUTPUT_VHDL");
+ bool multiPageIndex=FALSE;
+ int numPages=1;
+ if (documentedFileMembers[hl]>MAX_ITEMS_BEFORE_MULTIPAGE_INDEX)
+ {
+ multiPageIndex=TRUE;
+ numPages=127;
+ }
+
+ struct FmhlInfo
+ {
+ FmhlInfo(const char *fn,const char *t) : fname(fn), title(t) {}
+ const char *fname;
+ QCString title;
+ } 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())
+ };
+
+ ol.pushGeneratorState();
+ ol.disableAllBut(OutputGenerator::Html);
+
+ QCString extension=Doxygen::htmlFileExtension;
+ QCString title = fortranOpt?theTranslator->trCompoundMembersFortran():theTranslator->trCompoundMembers();
+
+ int page;
+ bool first=TRUE;
+ for (page=0;page<numPages;page++)
+ {
+ if (!multiPageIndex || g_fileIndexLetterUsed[hl][page].count()>0)
+ {
+ QCString fileName = fmhlInfo[hl].fname;
+ if (multiPageIndex && !first)
+ {
+ fileName+=QCString().sprintf("_0x%02x",page);
+ }
+
+ startFile(ol,fileName+extension,0,title.data(),HLI_Globals,TRUE);
+
+ startQuickIndexList(ol);
+
+ // index item for all member lists
+ startQuickIndexItem(ol,
+ fmhlInfo[0].fname+Doxygen::htmlFileExtension,hl==FMHL_All,TRUE,first);
+ ol.writeString(fixSpaces(fmhlInfo[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,
+ fmhlInfo[i].fname+Doxygen::htmlFileExtension,hl==i,TRUE,first);
+ ol.writeString(fixSpaces(fmhlInfo[i].title));
+ endQuickIndexItem(ol);
+ }
+ }
+
+ endQuickIndexList(ol);
+
+ bool quickIndex = documentedFileMembers[hl]>maxItemsBeforeQuickIndex;
+ if (quickIndex)
+ {
+ writeQuickMemberIndex(ol,g_fileIndexLetterUsed[hl],page,
+ fmhlInfo[hl].fname,multiPageIndex);
+ }
+
+ ol.endQuickIndices();
+ ol.startContents();
+
+ if (hl==FMHL_All)
+ {
+ ol.parseText(theTranslator->trFileMembersDescription(Config_getBool("EXTRACT_ALL")));
+ }
+ else
+ {
+ // hack to work around a mozilla bug, which refuses to switch to
+ // normal lists otherwise
+ ol.writeString(" ");
+ }
+ //ol.newParagraph(); // FIXME:PARA
+ //writeFileMemberList(ol,quickIndex,hl,page);
+ writeMemberList(ol,quickIndex,
+ multiPageIndex?page:-1,
+ g_fileIndexLetterUsed[hl],
+ Definition::TypeFile);
+ endFile(ol);
+ first=FALSE;
+ }
+ }
+ ol.popGeneratorState();
+}
+
+void writeFileMemberIndex(OutputList &ol)
+{
+ 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)
+ {
+ QCString title = theTranslator->trFileMembers();
+ Doxygen::indexList.addContentsItem(FALSE,title,0,"globals",0);
+ }
+}
+
+
+//----------------------------------------------------------------------------
+
+static void writeNamespaceMemberIndexFiltered(OutputList &ol,
+ NamespaceMemberHighlight hl)
+{
+ if (documentedNamespaceMembers[hl]==0) return;
+
+ bool fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN");
+ bool vhdlOpt = Config_getBool("OPTIMIZE_OUTPUT_VHDL");
+
+ bool multiPageIndex=FALSE;
+ int numPages=1;
+ if (documentedNamespaceMembers[hl]>MAX_ITEMS_BEFORE_MULTIPAGE_INDEX)
+ {
+ multiPageIndex=TRUE;
+ numPages=127;
+ }
+
+ struct NmhlInfo
+ {
+ NmhlInfo(const char *fn,const char *t) : fname(fn), title(t) {}
+ const char *fname;
+ QCString title;
+ } 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())
+ };
+
+ ol.pushGeneratorState();
+ ol.disableAllBut(OutputGenerator::Html);
+
+ QCString extension=Doxygen::htmlFileExtension;
+ QCString title = fortranOpt?theTranslator->trCompoundMembersFortran():theTranslator->trCompoundMembers();
+
+ int page;
+ bool first=TRUE;
+ for (page=0;page<numPages;page++)
+ {
+ if (!multiPageIndex || g_namespaceIndexLetterUsed[hl][page].count()>0)
+ {
+ QCString fileName = nmhlInfo[hl].fname;
+ if (multiPageIndex && !first)
+ {
+ fileName+=QCString().sprintf("_0x%02x",page);
+ }
+
+ startFile(ol,fileName+extension,0,title,HLI_NamespaceMembers,TRUE);
+
+ startQuickIndexList(ol);
+
+ startQuickIndexItem(ol,
+ nmhlInfo[0].fname+Doxygen::htmlFileExtension,hl==NMHL_All,TRUE,first);
+ ol.writeString(fixSpaces(nmhlInfo[0].title));
+ endQuickIndexItem(ol);
+
+ int i;
+ for (i=1;i<NMHL_Total;i++)
+ {
+ if (documentedNamespaceMembers[i]>0)
+ {
+ startQuickIndexItem(ol,
+ nmhlInfo[i].fname+Doxygen::htmlFileExtension,hl==i,TRUE,first);
+ ol.writeString(fixSpaces(nmhlInfo[i].title));
+ endQuickIndexItem(ol);
+ }
+ }
+
+ endQuickIndexList(ol);
+
+ bool quickIndex = documentedNamespaceMembers[hl]>maxItemsBeforeQuickIndex;
+ if (quickIndex)
+ {
+ writeQuickMemberIndex(ol,g_namespaceIndexLetterUsed[hl],page,
+ nmhlInfo[hl].fname,multiPageIndex);
+ }
+
+ ol.endQuickIndices();
+ ol.startContents();
+
+ if (hl==NMHL_All)
+ {
+ ol.parseText(fortranOpt?theTranslator->trModulesMemberDescription(Config_getBool("EXTRACT_ALL")):theTranslator->trNamespaceMemberDescription(Config_getBool("EXTRACT_ALL")));
+ }
+ else
+ {
+ // hack to work around a mozilla bug, which refuses to switch to
+ // normal lists otherwise
+ ol.writeString(" ");
+ }
+ //ol.newParagraph(); // FIXME:PARA
+
+ //writeNamespaceMemberList(ol,quickIndex,hl,page);
+ writeMemberList(ol,quickIndex,
+ multiPageIndex?page:-1,
+ g_namespaceIndexLetterUsed[hl],
+ Definition::TypeNamespace);
+ endFile(ol);
+ }
+ }
+ ol.popGeneratorState();
+}
+
+void writeNamespaceMemberIndex(OutputList &ol)
+{
+ 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)
+ {
+ QCString title = fortranOpt?theTranslator->trModulesMembers():theTranslator->trNamespaceMembers();
+ Doxygen::indexList.addContentsItem(FALSE,title,0,"namespacemembers",0);
+ }
+}
+
+//----------------------------------------------------------------------------
+
+#define NUM_SEARCH_INDICES 13
+#define SEARCH_INDEX_ALL 0
+#define SEARCH_INDEX_CLASSES 1
+#define SEARCH_INDEX_NAMESPACES 2
+#define SEARCH_INDEX_FILES 3
+#define SEARCH_INDEX_FUNCTIONS 4
+#define SEARCH_INDEX_VARIABLES 5
+#define SEARCH_INDEX_TYPEDEFS 6
+#define SEARCH_INDEX_ENUMS 7
+#define SEARCH_INDEX_ENUMVALUES 8
+#define SEARCH_INDEX_PROPERTIES 9
+#define SEARCH_INDEX_EVENTS 10
+#define SEARCH_INDEX_RELATED 11
+#define SEARCH_INDEX_DEFINES 12
+
+class SearchIndexList : public SDict< QList<Definition> >
+{
+ public:
+ SearchIndexList(int size=17) : SDict< QList<Definition> >(size,FALSE)
+ {
+ setAutoDelete(TRUE);
+ }
+ ~SearchIndexList() {}
+ void append(Definition *d)
+ {
+ QList<Definition> *l = find(d->name());
+ if (l==0)
+ {
+ l=new QList<Definition>;
+ SDict< QList<Definition> >::append(d->name(),l);
+ }
+ l->append(d);
+ }
+ int compareItems(GCI item1, GCI item2)
+ {
+ QList<Definition> *md1=(QList<Definition> *)item1;
+ QList<Definition> *md2=(QList<Definition> *)item2;
+ QCString n1 = md1->first()->localName();
+ QCString n2 = md2->first()->localName();
+ return stricmp(n1.data(),n2.data());
+ }
+};
+
+static void addMemberToSearchIndex(
+ SearchIndexList symbols[NUM_SEARCH_INDICES][MEMBER_INDEX_ENTRIES],
+ int symbolCount[NUM_SEARCH_INDICES],
+ MemberDef *md)
+{
+ static bool hideFriendCompounds = Config_getBool("HIDE_FRIEND_COMPOUNDS");
+ bool isLinkable = md->isLinkable();
+ ClassDef *cd=0;
+ NamespaceDef *nd=0;
+ FileDef *fd=0;
+ if (isLinkable &&
+ (cd=md->getClassDef()) &&
+ cd->isLinkable() &&
+ cd->templateMaster()==0)
+ {
+ QCString n = md->name();
+ uchar charCode = (uchar)n.at(0);
+ uint letter = charCode<128 ? tolower(charCode) : charCode;
+ 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))
+ {
+ symbols[SEARCH_INDEX_ALL][letter].append(md);
+ symbolCount[SEARCH_INDEX_ALL]++;
+ }
+ if (md->isFunction() || md->isSlot() || md->isSignal())
+ {
+ symbols[SEARCH_INDEX_FUNCTIONS][letter].append(md);
+ symbolCount[SEARCH_INDEX_FUNCTIONS]++;
+ }
+ else if (md->isVariable())
+ {
+ symbols[SEARCH_INDEX_VARIABLES][letter].append(md);
+ symbolCount[SEARCH_INDEX_VARIABLES]++;
+ }
+ else if (md->isTypedef())
+ {
+ symbols[SEARCH_INDEX_TYPEDEFS][letter].append(md);
+ symbolCount[SEARCH_INDEX_TYPEDEFS]++;
+ }
+ else if (md->isEnumerate())
+ {
+ symbols[SEARCH_INDEX_ENUMS][letter].append(md);
+ symbolCount[SEARCH_INDEX_ENUMS]++;
+ }
+ else if (md->isEnumValue())
+ {
+ symbols[SEARCH_INDEX_ENUMVALUES][letter].append(md);
+ symbolCount[SEARCH_INDEX_ENUMVALUES]++;
+ }
+ else if (md->isProperty())
+ {
+ symbols[SEARCH_INDEX_PROPERTIES][letter].append(md);
+ symbolCount[SEARCH_INDEX_PROPERTIES]++;
+ }
+ else if (md->isEvent())
+ {
+ symbols[SEARCH_INDEX_EVENTS][letter].append(md);
+ symbolCount[SEARCH_INDEX_EVENTS]++;
+ }
+ else if (md->isRelated() || md->isForeign() ||
+ (md->isFriend() && !isFriendToHide))
+ {
+ symbols[SEARCH_INDEX_RELATED][letter].append(md);
+ symbolCount[SEARCH_INDEX_RELATED]++;
+ }
+ }
+ }
+ else if (isLinkable &&
+ (((nd=md->getNamespaceDef()) && nd->isLinkable()) ||
+ ((fd=md->getFileDef()) && fd->isLinkable())
+ )
+ )
+ {
+ QCString n = md->name();
+ uchar charCode = (uchar)n.at(0);
+ uint letter = charCode<128 ? tolower(charCode) : charCode;
+ if (!n.isEmpty())
+ {
+ symbols[SEARCH_INDEX_ALL][letter].append(md);
+ symbolCount[SEARCH_INDEX_ALL]++;
+
+ if (md->isFunction())
+ {
+ symbols[SEARCH_INDEX_FUNCTIONS][letter].append(md);
+ symbolCount[SEARCH_INDEX_FUNCTIONS]++;
+ }
+ else if (md->isVariable())
+ {
+ symbols[SEARCH_INDEX_VARIABLES][letter].append(md);
+ symbolCount[SEARCH_INDEX_VARIABLES]++;
+ }
+ else if (md->isTypedef())
+ {
+ symbols[SEARCH_INDEX_TYPEDEFS][letter].append(md);
+ symbolCount[SEARCH_INDEX_TYPEDEFS]++;
+ }
+ else if (md->isEnumerate())
+ {
+ symbols[SEARCH_INDEX_ENUMS][letter].append(md);
+ symbolCount[SEARCH_INDEX_ENUMS]++;
+ }
+ else if (md->isEnumValue())
+ {
+ symbols[SEARCH_INDEX_ENUMVALUES][letter].append(md);
+ symbolCount[SEARCH_INDEX_ENUMVALUES]++;
+ }
+ else if (md->isDefine())
+ {
+ symbols[SEARCH_INDEX_DEFINES][letter].append(md);
+ symbolCount[SEARCH_INDEX_DEFINES]++;
+ }
+ }
+ }
+}
+
+static QCString searchId(const QCString &s)
+{
+ int c;
+ uint i;
+ QCString result;
+ for (i=0;i<s.length();i++)
+ {
+ c=s.at(i);
+ if ((c>='0' && c<='9') || (c>='A' && c<='Z') || (c>='a' && c<='z'))
+ {
+ result+=(char)tolower(c);
+ }
+ else
+ {
+ char val[4];
+ sprintf(val,"_%02x",c);
+ result+=val;
+ }
+ }
+ return result;
+}
+
+static int g_searchIndexCount[NUM_SEARCH_INDICES];
+static SearchIndexList g_searchIndexSymbols[NUM_SEARCH_INDICES][MEMBER_INDEX_ENTRIES];
+static const char *g_searchIndexName[NUM_SEARCH_INDICES] =
+{
+ "all",
+ "classes",
+ "namespaces",
+ "files",
+ "functions",
+ "variables",
+ "typedefs",
+ "enums",
+ "enumvalues",
+ "properties",
+ "events",
+ "related",
+ "defines"
+};
+
+
+class SearchIndexCategoryMapping
+{
+ public:
+ SearchIndexCategoryMapping()
+ {
+ categoryLabel[SEARCH_INDEX_ALL] = theTranslator->trAll();
+ categoryLabel[SEARCH_INDEX_CLASSES] = theTranslator->trClasses();
+ categoryLabel[SEARCH_INDEX_NAMESPACES] = theTranslator->trNamespace(TRUE,FALSE);
+ categoryLabel[SEARCH_INDEX_FILES] = theTranslator->trFile(TRUE,FALSE);
+ categoryLabel[SEARCH_INDEX_FUNCTIONS] = theTranslator->trFunctions();
+ categoryLabel[SEARCH_INDEX_VARIABLES] = theTranslator->trVariables();
+ categoryLabel[SEARCH_INDEX_TYPEDEFS] = theTranslator->trTypedefs();
+ categoryLabel[SEARCH_INDEX_ENUMS] = theTranslator->trEnumerations();
+ categoryLabel[SEARCH_INDEX_ENUMVALUES] = theTranslator->trEnumerationValues();
+ categoryLabel[SEARCH_INDEX_PROPERTIES] = theTranslator->trProperties();
+ categoryLabel[SEARCH_INDEX_EVENTS] = theTranslator->trEvents();
+ categoryLabel[SEARCH_INDEX_RELATED] = theTranslator->trFriends();
+ categoryLabel[SEARCH_INDEX_DEFINES] = theTranslator->trDefines();
+ }
+ QString categoryLabel[NUM_SEARCH_INDICES];
+};
+
+void writeJavascriptSearchIndex()
+{
+ if (!Config_getBool("GENERATE_HTML")) return;
+ static bool treeView = Config_getBool("GENERATE_TREEVIEW");
+
+ ClassSDict::Iterator cli(*Doxygen::classSDict);
+ ClassDef *cd;
+ for (;(cd=cli.current());++cli)
+ {
+ uchar charCode = (uchar)cd->localName().at(0);
+ uint letter = charCode<128 ? tolower(charCode) : charCode;
+ if (cd->isLinkable() && isId(letter))
+ {
+ g_searchIndexSymbols[SEARCH_INDEX_ALL][letter].append(cd);
+ g_searchIndexSymbols[SEARCH_INDEX_CLASSES][letter].append(cd);
+ g_searchIndexCount[SEARCH_INDEX_ALL]++;
+ g_searchIndexCount[SEARCH_INDEX_CLASSES]++;
+ }
+ }
+ NamespaceSDict::Iterator nli(*Doxygen::namespaceSDict);
+ NamespaceDef *nd;
+ for (;(nd=nli.current());++nli)
+ {
+ uchar charCode = (uchar)nd->name().at(0);
+ uint letter = charCode<128 ? tolower(charCode) : charCode;
+ if (nd->isLinkable() && isId(letter))
+ {
+ g_searchIndexSymbols[SEARCH_INDEX_ALL][letter].append(nd);
+ g_searchIndexSymbols[SEARCH_INDEX_NAMESPACES][letter].append(nd);
+ g_searchIndexCount[SEARCH_INDEX_ALL]++;
+ g_searchIndexCount[SEARCH_INDEX_NAMESPACES]++;
+ }
+ }
+ FileNameListIterator fnli(*Doxygen::inputNameList);
+ FileName *fn;
+ for (;(fn=fnli.current());++fnli)
+ {
+ FileNameIterator fni(*fn);
+ FileDef *fd;
+ for (;(fd=fni.current());++fni)
+ {
+ uchar charCode = (uchar)fd->name().at(0);
+ uint letter = charCode<128 ? tolower(charCode) : charCode;
+ if (fd->isLinkable() && isId(letter))
+ {
+ g_searchIndexSymbols[SEARCH_INDEX_ALL][letter].append(fd);
+ g_searchIndexSymbols[SEARCH_INDEX_FILES][letter].append(fd);
+ g_searchIndexCount[SEARCH_INDEX_ALL]++;
+ g_searchIndexCount[SEARCH_INDEX_FILES]++;
+ }
+ }
+ }
+ {
+ MemberNameSDict::Iterator mnli(*Doxygen::memberNameSDict);
+ MemberName *mn;
+ // for each member name
+ for (mnli.toFirst();(mn=mnli.current());++mnli)
+ {
+ MemberDef *md;
+ MemberNameIterator mni(*mn);
+ // for each member definition
+ for (mni.toFirst();(md=mni.current());++mni)
+ {
+ addMemberToSearchIndex(g_searchIndexSymbols,g_searchIndexCount,md);
+ }
+ }
+ }
+ {
+ MemberNameSDict::Iterator fnli(*Doxygen::functionNameSDict);
+ MemberName *mn;
+ // for each member name
+ for (fnli.toFirst();(mn=fnli.current());++fnli)
+ {
+ MemberDef *md;
+ MemberNameIterator mni(*mn);
+ // for each member definition
+ for (mni.toFirst();(md=mni.current());++mni)
+ {
+ addMemberToSearchIndex(g_searchIndexSymbols,g_searchIndexCount,md);
+ }
+ }
+ }
+
+ int i,p;
+ for (i=0;i<NUM_SEARCH_INDICES;i++)
+ {
+ for (p=0;p<MEMBER_INDEX_ENTRIES;p++)
+ {
+ if (g_searchIndexSymbols[i][p].count()>0)
+ {
+ g_searchIndexSymbols[i][p].sort();
+ }
+ }
+ }
+
+ QCString searchDirName = Config_getString("HTML_OUTPUT")+"/search";
+
+ for (i=0;i<NUM_SEARCH_INDICES;i++)
+ {
+ for (p=0;p<MEMBER_INDEX_ENTRIES;p++)
+ {
+ if (g_searchIndexSymbols[i][p].count()>0)
+ {
+ QCString fileName;
+ fileName.sprintf("/%s_%02x.html",g_searchIndexName[i],p);
+ fileName.prepend(searchDirName);
+ QFile outFile(fileName);
+ if (outFile.open(IO_WriteOnly))
+ {
+ QTextStream t(&outFile);
+ t << "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\""
+ " \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">" << endl;
+ t << "<html><head><title></title>" << endl;
+ t << "<meta http-equiv=\"Content-Type\" content=\"text/xhtml;charset=UTF-8\"/>" << endl;
+ t << "<link rel=\"stylesheet\" type=\"text/css\" href=\"search.css\"/>" << endl;
+ t << "<script type=\"text/javascript\" src=\"search.js\"></script>" << endl;
+ t << "</head>" << endl;
+ t << "<body class=\"SRPage\">" << endl;
+ t << "<div id=\"SRIndex\">" << endl;
+ t << "<div class=\"SRStatus\" id=\"Loading\">" << theTranslator->trLoading() << "</div>" << endl;
+
+ SDict<QList<Definition> >::Iterator li(g_searchIndexSymbols[i][p]);
+ QList<Definition> *dl;
+ int itemCount=0;
+ for (li.toFirst();(dl=li.current());++li)
+ {
+ Definition *d = dl->first();
+ QCString id = d->localName();
+ t << "<div class=\"SRResult\" id=\"SR_"
+ << searchId(d->localName()) << "\">" << endl;
+ t << " <div class=\"SREntry\">\n";
+ if (dl->count()==1) // item with a unique name
+ {
+ MemberDef *md = 0;
+ bool isMemberDef = d->definitionType()==Definition::TypeMember;
+ if (isMemberDef) md = (MemberDef*)d;
+ t << " <a id=\"Item" << itemCount << "\" "
+ << "onkeydown=\""
+ << "return searchResults.Nav(event," << itemCount << ")\" "
+ << "onkeypress=\""
+ << "return searchResults.Nav(event," << itemCount << ")\" "
+ << "onkeyup=\""
+ << "return searchResults.Nav(event," << itemCount << ")\" "
+ << "class=\"SRSymbol\" ";
+ if (!d->getReference().isEmpty())
+ {
+ QCString *dest;
+ t << "doxygen=\"" << d->getReference() << ":../";
+ if ((dest=Doxygen::tagDestinationDict[d->getReference()])) t << *dest << "/";
+ t << "\" ";
+ t << "href=\"../";
+ if ((dest=Doxygen::tagDestinationDict[d->getReference()])) t << *dest << "/";
+ }
+ else
+ {
+ t << "href=\"../";
+ }
+ t << d->getOutputFileBase() << Doxygen::htmlFileExtension;
+ if (isMemberDef)
+ {
+ t << "#" << ((MemberDef *)d)->anchor();
+ }
+ t << "\" target=\"";
+ if (treeView) t << "basefrm"; else t << "_parent";
+ t << "\">";
+ t << convertToXML(d->localName());
+ t << "</a>" << endl;
+ if (d->getOuterScope()!=Doxygen::globalScope)
+ {
+ t << " <span class=\"SRScope\">"
+ << convertToXML(d->getOuterScope()->name())
+ << "</span>" << endl;
+ }
+ else if (isMemberDef)
+ {
+ FileDef *fd = ((MemberDef *)d)->getBodyDef();
+ if (fd==0) fd = ((MemberDef *)d)->getFileDef();
+ if (fd)
+ {
+ t << " <span class=\"SRScope\">"
+ << convertToXML(fd->localName())
+ << "</span>" << endl;
+ }
+ }
+ }
+ else // multiple items with the same name
+ {
+ t << " <a id=\"Item" << itemCount << "\" "
+ << "onkeydown=\""
+ << "return searchResults.Nav(event," << itemCount << ")\" "
+ << "onkeypress=\""
+ << "return searchResults.Nav(event," << itemCount << ")\" "
+ << "onkeyup=\""
+ << "return searchResults.Nav(event," << itemCount << ")\" "
+ << "class=\"SRSymbol\" "
+ << "href=\"javascript:searchResults.Toggle('SR_"
+ << searchId(d->localName()) << "')\">"
+ << convertToXML(d->localName()) << "</a>" << endl;
+ t << " <div class=\"SRChildren\">" << endl;
+
+ QListIterator<Definition> di(*dl);
+ bool overloadedFunction = FALSE;
+ Definition *prevScope = 0;
+ int childCount=0;
+ for (di.toFirst();(d=di.current());)
+ {
+ ++di;
+ Definition *scope = d->getOuterScope();
+ Definition *next = di.current();
+ Definition *nextScope = 0;
+ MemberDef *md = 0;
+ bool isMemberDef = d->definitionType()==Definition::TypeMember;
+ if (isMemberDef) md = (MemberDef*)d;
+ if (next) nextScope = next->getOuterScope();
+
+ t << " <a id=\"Item" << itemCount << "_c"
+ << childCount << "\" "
+ << "onkeydown=\""
+ << "return searchResults.NavChild(event,"
+ << itemCount << "," << childCount << ")\" "
+ << "onkeypress=\""
+ << "return searchResults.NavChild(event,"
+ << itemCount << "," << childCount << ")\" "
+ << "onkeyup=\""
+ << "return searchResults.NavChild(event,"
+ << itemCount << "," << childCount << ")\" "
+ << "class=\"SRScope\" ";
+ if (!d->getReference().isEmpty())
+ {
+ QCString *dest;
+ t << "doxygen=\"" << d->getReference() << ":../";
+ if ((dest=Doxygen::tagDestinationDict[d->getReference()])) t << *dest << "/";
+ t << "\" ";
+ t << "href=\"../";
+ if ((dest=Doxygen::tagDestinationDict[d->getReference()])) t << *dest << "/";
+ }
+ else
+ {
+ t << "href=\"../";
+ }
+ t << d->getOutputFileBase() << Doxygen::htmlFileExtension;
+ if (isMemberDef)
+ {
+ t << "#" << ((MemberDef *)d)->anchor();
+ }
+ t << "\" target=\"";
+ if (treeView) t << "basefrm"; else t << "_parent";
+ t << "\">";
+ bool found=FALSE;
+ overloadedFunction = ((prevScope!=0 && scope==prevScope) ||
+ (scope && scope==nextScope)
+ ) && md &&
+ (md->isFunction() || md->isSlot());
+ QCString prefix;
+ if (md) prefix=convertToXML(md->localName());
+ if (overloadedFunction) // overloaded member function
+ {
+ prefix+=convertToXML(md->argsString());
+ // show argument list to disambiguate overloaded functions
+ }
+ else if (md) // unique member function
+ {
+ prefix+="()"; // only to show it is a function
+ }
+ if (d->definitionType()==Definition::TypeClass)
+ {
+ t << convertToXML(((ClassDef*)d)->displayName());
+ found = TRUE;
+ }
+ else if (d->definitionType()==Definition::TypeNamespace)
+ {
+ t << convertToXML(((NamespaceDef*)d)->displayName());
+ found = TRUE;
+ }
+ else if (scope==0 || scope==Doxygen::globalScope) // in global scope
+ {
+ if (md)
+ {
+ FileDef *fd = md->getBodyDef();
+ if (fd==0) fd = md->getFileDef();
+ if (fd)
+ {
+ if (!prefix.isEmpty()) prefix+=": ";
+ t << prefix << convertToXML(fd->localName());
+ found = TRUE;
+ }
+ }
+ }
+ else if (md && (md->getClassDef() || md->getNamespaceDef()))
+ // member in class or namespace scope
+ {
+ static bool optimizeOutputJava = Config_getBool("OPTIMIZE_OUTPUT_JAVA");
+ t << convertToXML(d->getOuterScope()->qualifiedName()) << (optimizeOutputJava ? "." : "::");
+ t << prefix;
+ found = TRUE;
+ }
+ else if (scope) // some thing else? -> show scope
+ {
+ t << prefix << convertToXML(scope->name());
+ found = TRUE;
+ }
+ if (!found) // fallback
+ {
+ t << prefix << "("+theTranslator->trGlobalNamespace()+")";
+ }
+ t << "</a>" << endl;
+ prevScope = scope;
+ childCount++;
+ }
+ t << " </div>" << endl; // SRChildren
+ }
+ t << " </div>" << endl; // SREntry
+ t << "</div>" << endl; // SRResult
+ itemCount++;
+ }
+ t << "<div class=\"SRStatus\" id=\"Searching\">"
+ << theTranslator->trSearching() << "</div>" << endl;
+ t << "<div class=\"SRStatus\" id=\"NoMatches\">"
+ << theTranslator->trNoMatches() << "</div>" << endl;
+
+ t << "<script type=\"text/javascript\"><!--" << endl;
+ t << "document.getElementById(\"Loading\").style.display=\"none\";" << endl;
+ t << "document.getElementById(\"NoMatches\").style.display=\"none\";" << endl;
+ t << "var searchResults = new SearchResults(\"searchResults\");" << endl;
+ t << "searchResults.Search();" << endl;
+ t << "--></script>" << endl;
+
+ t << "</div>" << endl; // SRIndex
+
+ t << "</body>" << endl;
+ t << "</html>" << endl;
+
+ }
+ else
+ {
+ err("Failed to open file '%s' for writing...\n",fileName.data());
+ }
+ }
+ }
+ }
+ //ol.popGeneratorState();
+
+ {
+ QFile f(searchDirName+"/search.js");
+ if (f.open(IO_WriteOnly))
+ {
+ QTextStream t(&f);
+ t << "// Search script generated by doxygen" << endl;
+ t << "// Copyright (C) 2009 by Dimitri van Heesch." << endl << endl;
+ t << "// The code in this file is loosly based on main.js, part of Natural Docs," << endl;
+ t << "// which is Copyright (C) 2003-2008 Greg Valure" << endl;
+ t << "// Natural Docs is licensed under the GPL." << endl << endl;
+ t << "var indexSectionsWithContent =" << endl;
+ t << "{" << endl;
+ bool first=TRUE;
+ int j=0;
+ for (i=0;i<NUM_SEARCH_INDICES;i++)
+ {
+ if (g_searchIndexCount[i]>0)
+ {
+ if (!first) t << "," << endl;
+ t << " " << j << ": \"";
+ for (p=0;p<MEMBER_INDEX_ENTRIES;p++)
+ {
+ t << (g_searchIndexSymbols[i][p].count()>0 ? "1" : "0");
+ }
+ t << "\"";
+ first=FALSE;
+ j++;
+ }
+ }
+ if (!first) t << "\n";
+ t << "};" << endl << endl;
+ t << "var indexSectionNames =" << endl;
+ t << "{" << endl;
+ first=TRUE;
+ j=0;
+ for (i=0;i<NUM_SEARCH_INDICES;i++)
+ {
+ if (g_searchIndexCount[i]>0)
+ {
+ if (!first) t << "," << endl;
+ t << " " << j << ": \"" << g_searchIndexName[i] << "\"";
+ first=FALSE;
+ j++;
+ }
+ }
+ if (!first) t << "\n";
+ t << "};" << endl << endl;
+ t << search_script;
+ }
+ }
+ {
+ QFile f(searchDirName+"/nomatches.html");
+ if (f.open(IO_WriteOnly))
+ {
+ QTextStream t(&f);
+ t << "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" "
+ "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">" << endl;
+ t << "<html><head><title></title>" << endl;
+ t << "<meta http-equiv=\"Content-Type\" content=\"text/xhtml;charset=UTF-8\"/>" << endl;
+ t << "<link rel=\"stylesheet\" type=\"text/css\" href=\"search.css\"/>" << endl;
+ t << "<script type=\"text/javascript\" src=\"search.js\"></script>" << endl;
+ t << "</head>" << endl;
+ t << "<body class=\"SRPage\">" << endl;
+ t << "<div id=\"SRIndex\">" << endl;
+ t << "<div class=\"SRStatus\" id=\"NoMatches\">"
+ << theTranslator->trNoMatches() << "</div>" << endl;
+ t << "</div>" << endl;
+ t << "</body>" << endl;
+ t << "</html>" << endl;
+ }
+ }
+ Doxygen::indexList.addStyleSheetFile("search/search.js");
+}
+
+void writeSearchStyleSheet()
+{
+ QCString searchDirName = Config_getString("HTML_OUTPUT")+"/search";
+ QFile f(searchDirName+"/search.css");
+ if (f.open(IO_WriteOnly))
+ {
+ QTextStream t(&f);
+ t << search_styleSheet;
+ }
+ Doxygen::indexList.addStyleSheetFile("search/search.css");
+}
+
+void writeSearchCategories(QTextStream &t)
+{
+ static SearchIndexCategoryMapping map;
+ int i,j=0;
+ for (i=0;i<NUM_SEARCH_INDICES;i++)
+ {
+ if (g_searchIndexCount[i]>0)
+ {
+ t << "<a class=\"SelectItem\" href=\"javascript:void(0)\" "
+ << "onclick=\"searchBox.OnSelectItem(" << j << ")\">"
+ << "<span class=\"SelectionMark\"> </span>"
+ << convertToXML(map.categoryLabel[i])
+ << "</a>";
+ j++;
+ }
+ }
+}
+
+//----------------------------------------------------------------------------
+
+void writeExampleIndex(OutputList &ol)
+{
+ if (Doxygen::exampleSDict->count()==0) return;
+ ol.pushGeneratorState();
+ ol.disable(OutputGenerator::Man);
+ QCString title = theTranslator->trExamples();
+ startFile(ol,"examples",0,title.data(),HLI_Examples);
+ startTitle(ol,0);
+ //if (!Config_getString("PROJECT_NAME").isEmpty())
+ //{
+ // title.prepend(Config_getString("PROJECT_NAME")+" ");
+ //}
+ ol.parseText(title);
+ endTitle(ol,0,0);
+ ol.startTextBlock();
+ Doxygen::indexList.addContentsItem(TRUE,theTranslator->trExamples(),0,"examples",0);
+ Doxygen::indexList.incContentsDepth();
+ ol.parseText(theTranslator->trExamplesDescription());
+ //ol.newParagraph();
+ 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());
+ Doxygen::indexList.addContentsItem(FALSE,filterTitle(pd->title()),pd->getReference(),n,0);
+ }
+ else
+ {
+ ol.writeObjectLink(0,n,0,pd->name());
+ Doxygen::indexList.addContentsItem(FALSE,pd->name(),pd->getReference(),n,0);
+ }
+ ol.endItemListItem();
+ ol.writeString("\n");
+ }
+ ol.endItemList();
+ Doxygen::indexList.decContentsDepth();
+ endFile(ol);
+ ol.popGeneratorState();
+}
+
+//----------------------------------------------------------------------------
+
+void countRelatedPages(int &docPages,int &indexPages)
+{
+ 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 void writeSubPages(PageDef *pd)
+{
+ //printf("Write subpages(%s #=%d)\n",pd->name().data(),pd->getSubPages() ? pd->getSubPages()->count() : 0 );
+ Doxygen::indexList.incContentsDepth();
+
+ PageSDict *subPages = pd->getSubPages();
+ if (subPages)
+ {
+ PageSDict::Iterator pi(*subPages);
+ PageDef *subPage;
+ for (pi.toFirst();(subPage=pi.current());++pi)
+ {
+ QCString pageTitle;
+
+ if (subPage->title().isEmpty())
+ pageTitle=subPage->name();
+ else
+ pageTitle=subPage->title();
+
+ bool hasSubPages = subPage->hasSubPages();
+
+ Doxygen::indexList.addContentsItem(hasSubPages,pageTitle,subPage->getReference(),subPage->getOutputFileBase(),0);
+ writeSubPages(subPage);
+ }
+ }
+ Doxygen::indexList.decContentsDepth();
+
+}
+
+void writePageIndex(OutputList &ol)
+{
+ if (indexedPages==0) return;
+ ol.pushGeneratorState();
+ ol.disableAllBut(OutputGenerator::Html);
+ startFile(ol,"pages",0,theTranslator->trPageIndex().data(),HLI_Pages);
+ startTitle(ol,0);
+ QCString title = theTranslator->trRelatedPages();
+ //if (!Config_getString("PROJECT_NAME").isEmpty())
+ //{
+ // title.prepend(Config_getString("PROJECT_NAME")+" ");
+ //}
+ ol.parseText(title);
+ endTitle(ol,0,0);
+ ol.startTextBlock();
+ //Doxygen::indexList.addContentsItem(TRUE,theTranslator->trRelatedPages(),0,"pages",0);
+ //Doxygen::indexList.incContentsDepth();
+ ol.parseText(theTranslator->trRelatedPagesDescription());
+ ol.endTextBlock();
+ startIndexHierarchy(ol,0);
+ PageSDict::Iterator pdi(*Doxygen::pageSDict);
+ PageDef *pd=0;
+ for (pdi.toFirst();(pd=pdi.current());++pdi)
+ {
+ if ( pd->visibleInIndex())
+ {
+ QCString pageTitle;
+
+ if (pd->title().isEmpty())
+ pageTitle=pd->name();
+ else
+ pageTitle=pd->title();
+
+ bool hasSubPages = pd->hasSubPages();
+
+ ol.startIndexListItem();
+ ol.startIndexItem(pd->getReference(),pd->getOutputFileBase());
+ ol.parseText(pageTitle);
+ ol.endIndexItem(pd->getReference(),pd->getOutputFileBase());
+ if (pd->isReference())
+ {
+ ol.startTypewriter();
+ ol.docify(" [external]");
+ ol.endTypewriter();
+ }
+ ol.writeString("\n");
+ Doxygen::indexList.addContentsItem(hasSubPages,filterTitle(pageTitle),pd->getReference(),pd->getOutputFileBase(),0);
+ writeSubPages(pd);
+ ol.endIndexListItem();
+ }
+ }
+ endIndexHierarchy(ol,0);
+ //Doxygen::indexList.decContentsDepth();
+ endFile(ol);
+ ol.popGeneratorState();
+}
+
+//----------------------------------------------------------------------------
+
+int countGroups()
+{
+ 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;
+}
+
+//----------------------------------------------------------------------------
+
+int countDirs()
+{
+ 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;
+}
+
+
+//----------------------------------------------------------------------------
+
+void writeGraphInfo(OutputList &ol)
+{
+ if (!Config_getBool("HAVE_DOT") || !Config_getBool("GENERATE_HTML")) return;
+ ol.pushGeneratorState();
+ ol.disableAllBut(OutputGenerator::Html);
+ generateGraphLegend(Config_getString("HTML_OUTPUT"));
+ startFile(ol,"graph_legend",0,theTranslator->trLegendTitle().data());
+ startTitle(ol,0);
+ ol.parseText(theTranslator->trLegendTitle());
+ endTitle(ol,0,0);
+ bool oldStripCommentsState = Config_getBool("STRIP_CODE_COMMENTS");
+ // temporarily disable the stripping of comments for our own code example!
+ Config_getBool("STRIP_CODE_COMMENTS") = FALSE;
+ ol.parseDoc("graph_legend",1,0,0,theTranslator->trLegendDocs(),FALSE,FALSE);
+ Config_getBool("STRIP_CODE_COMMENTS") = oldStripCommentsState;
+ endFile(ol);
+ ol.popGeneratorState();
+}
+
+void writeGroupIndexItem(GroupDef *gd,MemberList *ml,const QCString &title)
+{
+ if (ml && ml->count()>0)
+ {
+ bool first=TRUE;
+ MemberDef *md=ml->first();
+ while (md)
+ {
+ if (md->isDetailedSectionVisible(TRUE,FALSE))
+ {
+ if (first)
+ {
+ first=FALSE;
+ Doxygen::indexList.addContentsItem(TRUE, convertToHtml(title,TRUE), gd->getReference(), gd->getOutputFileBase(), 0);
+ Doxygen::indexList.incContentsDepth();
+ }
+ Doxygen::indexList.addContentsItem(FALSE,md->name(),md->getReference(),md->getOutputFileBase(),md->anchor());
+ }
+ md=ml->next();
+ }
+
+ if (!first)
+ {
+ Doxygen::indexList.decContentsDepth();
+ }
+ }
+}
+
+//----------------------------------------------------------------------------
+/*!
+ * write groups as hierarchical trees
+ */
+void writeGroupTreeNode(OutputList &ol, GroupDef *gd, int level, FTVHelp* ftv)
+{
+ bool fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN");
+ bool vhdlOpt = Config_getBool("OPTIMIZE_OUTPUT_VHDL");
+ if (level>20)
+ {
+ warn(gd->getDefFileName(),gd->getDefLine(),
+ "Warning: 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->visited &&*/ (!gd->isASubGroup() || level>0) &&
+ (!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->groupList->count()>0;
+ bool hasSubPages = gd->pageDict->count()>0;
+ int numSubItems = 0;
+ if ( Config_getBool("TOC_EXPAND"))
+ {
+ QListIterator<MemberList> mli(gd->getMemberLists());
+ MemberList *ml;
+ for (mli.toFirst();(ml=mli.current());++mli)
+ {
+ if (ml->listType()&MemberList::documentationLists)
+ {
+ numSubItems += ml->count();
+ }
+ }
+ numSubItems += gd->namespaceSDict->count();
+ numSubItems += gd->classSDict->count();
+ numSubItems += gd->fileList->count();
+ numSubItems += gd->exampleDict->count();
+ }
+
+ bool isDir = hasSubGroups || hasSubPages || numSubItems>0;
+ //printf("gd=`%s': pageDict=%d\n",gd->name().data(),gd->pageDict->count());
+ Doxygen::indexList.addContentsItem(isDir,gd->groupTitle(),gd->getReference(),gd->getOutputFileBase(),0);
+ Doxygen::indexList.incContentsDepth();
+ if (ftv)
+ {
+ ftv->addContentsItem(isDir,gd->groupTitle(),gd->getReference(),gd->getOutputFileBase(),0);
+ 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();
+ }
+
+ //ol.writeStartAnnoItem(0,gd->getOutputFileBase(),0,gd-);
+ //parseText(ol,gd->groupTitle());
+ //ol.writeEndAnnoItem(gd->getOutputFileBase());
+
+ // write pages
+ PageSDict::Iterator pli(*gd->pageDict);
+ PageDef *pd = 0;
+ for (pli.toFirst();(pd=pli.current());++pli)
+ {
+ SectionInfo *si=0;
+ if (!pd->name().isEmpty()) si=Doxygen::sectionDict[pd->name()];
+ Doxygen::indexList.addContentsItem(FALSE,
+ convertToHtml(pd->title(),TRUE),
+ gd->getReference(),
+ gd->getOutputFileBase(),
+ si ? si->label.data() : 0);
+ }
+
+ // write subgroups
+ if (hasSubGroups)
+ {
+ startIndexHierarchy(ol,level+1);
+ if (Config_getBool("SORT_GROUP_NAMES"))
+ gd->groupList->sort();
+ QListIterator<GroupDef> gli(*gd->groupList);
+ GroupDef *subgd = 0;
+ for (gli.toFirst();(subgd=gli.current());++gli)
+ {
+ writeGroupTreeNode(ol,subgd,level+1,ftv);
+ }
+ endIndexHierarchy(ol,level+1);
+ }
+
+
+ if (Config_getBool("TOC_EXPAND"))
+ {
+ writeGroupIndexItem(gd,gd->getMemberList(MemberList::docDefineMembers),
+ theTranslator->trDefines());
+ writeGroupIndexItem(gd,gd->getMemberList(MemberList::docTypedefMembers),
+ theTranslator->trTypedefs());
+ writeGroupIndexItem(gd,gd->getMemberList(MemberList::docEnumMembers),
+ theTranslator->trEnumerations());
+ writeGroupIndexItem(gd,gd->getMemberList(MemberList::docFuncMembers),
+ fortranOpt ? theTranslator->trSubprograms() :
+ vhdlOpt ? VhdlDocGen::trFunctionAndProc() :
+ theTranslator->trFunctions()
+ );
+ writeGroupIndexItem(gd,gd->getMemberList(MemberList::docVarMembers),
+ theTranslator->trVariables());
+ writeGroupIndexItem(gd,gd->getMemberList(MemberList::docProtoMembers),
+ theTranslator->trFuncProtos());
+
+ // write namespaces
+ NamespaceSDict *namespaceSDict=gd->namespaceSDict;
+ if (namespaceSDict->count()>0)
+ {
+ Doxygen::indexList.addContentsItem(TRUE,convertToHtml(fortranOpt?theTranslator->trModules():theTranslator->trNamespaces(),TRUE),gd->getReference(), gd->getOutputFileBase(), 0);
+ Doxygen::indexList.incContentsDepth();
+
+ NamespaceSDict::Iterator ni(*namespaceSDict);
+ NamespaceDef *nsd;
+ for (ni.toFirst();(nsd=ni.current());++ni)
+ {
+ Doxygen::indexList.addContentsItem(FALSE, convertToHtml(nsd->name(),TRUE), nsd->getReference(), nsd->getOutputFileBase(), 0);
+ }
+ Doxygen::indexList.decContentsDepth();
+ }
+
+ // write classes
+ if (gd->classSDict->count()>0)
+ {
+ Doxygen::indexList.addContentsItem(TRUE,convertToHtml(fortranOpt?theTranslator->trDataTypes():theTranslator->trClasses(),TRUE), gd->getReference(), gd->getOutputFileBase(), 0);
+ Doxygen::indexList.incContentsDepth();
+
+ ClassDef *cd;
+ ClassSDict::Iterator cdi(*gd->classSDict);
+ for (cdi.toFirst();(cd=cdi.current());++cdi)
+ {
+ if (cd->isLinkable())
+ {
+ //printf("node: Has children %s\n",cd->name().data());
+ Doxygen::indexList.addContentsItem(FALSE,cd->displayName(),cd->getReference(),cd->getOutputFileBase(),0);
+ }
+ }
+
+ //writeClassTree(gd->classSDict,1);
+ Doxygen::indexList.decContentsDepth();
+ }
+
+ // write file list
+ FileList *fileList=gd->fileList;
+ if (fileList->count()>0)
+ {
+ Doxygen::indexList.addContentsItem(TRUE,
+ theTranslator->trFile(TRUE,FALSE),
+ gd->getReference(),
+ gd->getOutputFileBase(), 0);
+ Doxygen::indexList.incContentsDepth();
+
+ FileDef *fd=fileList->first();
+ while (fd)
+ {
+ Doxygen::indexList.addContentsItem(FALSE, convertToHtml(fd->name(),TRUE),fd->getReference(), fd->getOutputFileBase(), 0);
+ fd=fileList->next();
+ }
+ Doxygen::indexList.decContentsDepth();
+ }
+
+ // write examples
+ if (gd->exampleDict->count()>0)
+ {
+ Doxygen::indexList.addContentsItem(TRUE, convertToHtml(theTranslator->trExamples(),TRUE),gd->getReference(), gd->getOutputFileBase(), 0);
+ Doxygen::indexList.incContentsDepth();
+
+ PageSDict::Iterator eli(*(gd->exampleDict));
+ PageDef *pd=eli.toFirst();
+ while (pd)
+ {
+ Doxygen::indexList.addContentsItem(FALSE,pd->name(),pd->getReference(),pd->getOutputFileBase(),0);
+ pd=++eli;
+ }
+
+ Doxygen::indexList.decContentsDepth();
+ }
+ }
+ ol.endIndexListItem();
+
+ Doxygen::indexList.decContentsDepth();
+ if (ftv)
+ ftv->decContentsDepth();
+ //gd->visited=TRUE;
+ }
+}
+
+void writeGroupHierarchy(OutputList &ol, FTVHelp* ftv)
+{
+ if (ftv)
+ {
+ ol.pushGeneratorState();
+ ol.disable(OutputGenerator::Html);
+ }
+ startIndexHierarchy(ol,0);
+ if (Config_getBool("SORT_GROUP_NAMES"))
+ Doxygen::groupSDict->sort();
+ GroupSDict::Iterator gli(*Doxygen::groupSDict);
+ GroupDef *gd;
+ for (gli.toFirst();(gd=gli.current());++gli)
+ {
+ writeGroupTreeNode(ol,gd,0,ftv);
+ }
+ endIndexHierarchy(ol,0);
+ if (ftv)
+ ol.popGeneratorState();
+}
+
+//----------------------------------------------------------------------------
+void writeDirTreeNode(OutputList &ol, DirDef *dd, int level, FTVHelp* ftv)
+{
+ if (level>20)
+ {
+ warn(dd->getDefFileName(),dd->getDefLine(),
+ "Warning: maximum nesting level exceeded for directory %s: "
+ "check for possible recursive directory relation!\n",dd->name().data()
+ );
+ return;
+ }
+
+ static bool tocExpand = 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());
+ Doxygen::indexList.addContentsItem(isDir,dd->shortName(),dd->getReference(),dd->getOutputFileBase(),0);
+ Doxygen::indexList.incContentsDepth();
+ if (ftv)
+ {
+ ftv->addContentsItem(isDir,dd->shortName(),dd->getReference(),dd->getOutputFileBase(),0);
+ 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);
+ }
+ endIndexHierarchy(ol,level+1);
+ }
+
+ if (tocExpand)
+ {
+ // write files of this directory
+ FileList *fileList=dd->getFiles();
+ if (fileList && fileList->count()>0)
+ {
+ FileDef *fd=fileList->first();
+ while (fd)
+ {
+ Doxygen::indexList.addContentsItem(FALSE, convertToHtml(fd->name(),TRUE),fd->getReference(), fd->getOutputFileBase(), 0);
+ fd=fileList->next();
+ }
+ }
+ }
+ ol.endIndexListItem();
+
+ Doxygen::indexList.decContentsDepth();
+ if (ftv)
+ ftv->decContentsDepth();
+}
+
+void writeDirHierarchy(OutputList &ol, FTVHelp* ftv)
+{
+ if (ftv)
+ {
+ ol.pushGeneratorState();
+ ol.disable(OutputGenerator::Html);
+ }
+ startIndexHierarchy(ol,0);
+ 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);
+ }
+ endIndexHierarchy(ol,0);
+ if (ftv)
+ ol.popGeneratorState();
+}
+
+//----------------------------------------------------------------------------
+
+void writeGroupIndex(OutputList &ol)
+{
+ if (documentedGroups==0) return;
+ ol.pushGeneratorState();
+ ol.disable(OutputGenerator::Man);
+ startFile(ol,"modules",0,theTranslator->trModuleIndex().data(),HLI_Modules);
+ startTitle(ol,0);
+ QCString title = theTranslator->trModules();
+ //if (!Config_getString("PROJECT_NAME").isEmpty())
+ //{
+ // title.prepend(Config_getString("PROJECT_NAME")+" ");
+ //}
+ ol.parseText(title);
+ endTitle(ol,0,0);
+ ol.startTextBlock();
+ Doxygen::indexList.addContentsItem(TRUE,theTranslator->trModules(),0,"modules",0);
+ Doxygen::indexList.incContentsDepth();
+ ol.parseText(theTranslator->trModulesDescription());
+ ol.endTextBlock();
+
+ FTVHelp* ftv = 0;
+ bool treeView=Config_getBool("USE_INLINE_TREES");
+ if (treeView)
+ ftv = new FTVHelp(false);
+
+ writeGroupHierarchy(ol,ftv);
+
+ Doxygen::indexList.decContentsDepth();
+ if (ftv)
+ {
+ QString OutStr;
+ ftv->generateTreeView(&OutStr);
+ ol.pushGeneratorState();
+ ol.disableAllBut(OutputGenerator::Html);
+ ol.writeString(OutStr);
+ ol.popGeneratorState();
+ delete ftv;
+ }
+ endFile(ol);
+ ol.popGeneratorState();
+}
+
+//----------------------------------------------------------------------------
+
+void writeDirIndex(OutputList &ol)
+{
+ if (documentedDirs==0) return;
+ ol.pushGeneratorState();
+ ol.disable(OutputGenerator::Man);
+ startFile(ol,"dirs",0,theTranslator->trDirIndex().data(),HLI_Directories);
+ startTitle(ol,0);
+ QCString title = theTranslator->trDirectories();
+ //if (!Config_getString("PROJECT_NAME").isEmpty())
+ //{
+ // title.prepend(Config_getString("PROJECT_NAME")+" ");
+ //}
+ ol.parseText(title);
+ endTitle(ol,0,0);
+ ol.startTextBlock();
+ Doxygen::indexList.addContentsItem(TRUE,theTranslator->trDirIndex(),0,"dirs",0);
+ Doxygen::indexList.incContentsDepth();
+ ol.parseText(theTranslator->trDirDescription());
+ ol.endTextBlock();
+
+ FTVHelp* ftv = 0;
+ bool treeView=Config_getBool("USE_INLINE_TREES");
+ if (treeView)
+ ftv = new FTVHelp(false);
+
+ writeDirHierarchy(ol,ftv);
+
+ if (ftv)
+ {
+ QString OutStr;
+ ftv->generateTreeView(&OutStr);
+ ol.pushGeneratorState();
+ ol.disableAllBut(OutputGenerator::Html);
+ ol.writeString(OutStr);
+ ol.popGeneratorState();
+ delete ftv;
+ }
+ Doxygen::indexList.decContentsDepth();
+ endFile(ol);
+ ol.popGeneratorState();
+}
+
+//----------------------------------------------------------------------------
+
+static bool mainPageHasTitle()
+{
+ if (Doxygen::mainPage==0) return FALSE;
+ if (Doxygen::mainPage->title().isEmpty()) return FALSE;
+ if (Doxygen::mainPage->title().lower()=="notitle") return FALSE;
+ return TRUE;
+}
+
+//----------------------------------------------------------------------------
+
+void writeIndex(OutputList &ol)
+{
+ static bool fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN");
+ static bool vhdlOpt = Config_getBool("OPTIMIZE_OUTPUT_VHDL");
+ // save old generator state
+ ol.pushGeneratorState();
+
+ QCString projPrefix;
+ if (!Config_getString("PROJECT_NAME").isEmpty())
+ {
+ projPrefix=Config_getString("PROJECT_NAME")+" ";
+ }
+
+ //--------------------------------------------------------------------
+ // write HTML index
+ //--------------------------------------------------------------------
+ ol.disableAllBut(OutputGenerator::Html);
+
+ QCString defFileName =
+ Doxygen::mainPage ? Doxygen::mainPage->getDefFileName().data() : "[generated]";
+ int defLine =
+ Doxygen::mainPage ? Doxygen::mainPage->getDefLine() : -1;
+
+ QCString title;
+ if (!mainPageHasTitle())
+ {
+ title = theTranslator->trMainPage();
+ }
+ else
+ {
+ title = filterTitle(Doxygen::mainPage->title());
+ }
+
+ QCString indexName=Config_getBool("GENERATE_TREEVIEW")?"main":"index";
+ ol.startFile(indexName,0,title);
+
+ if (Doxygen::mainPage)
+ {
+ Doxygen::indexList.addContentsItem(Doxygen::mainPage->hasSubPages(),title,0,indexName,0);
+
+ if (Doxygen::mainPage->hasSubPages())
+ {
+ writeSubPages(Doxygen::mainPage);
+ }
+ }
+
+ if (!Config_getBool("DISABLE_INDEX"))
+ {
+ ol.startQuickIndices();
+ ol.writeQuickLinks(TRUE,HLI_Main);
+ ol.endQuickIndices();
+ }
+ ol.startContents();
+ ol.startTitleHead(0);
+ if (Doxygen::mainPage && !Doxygen::mainPage->title().isEmpty())
+ {
+ if (Doxygen::mainPage->title().lower()!="notitle")
+ {
+ ol.parseDoc(Doxygen::mainPage->docFile(),Doxygen::mainPage->docLine(),
+ Doxygen::mainPage,0,Doxygen::mainPage->title(),
+ TRUE,FALSE,0,TRUE,FALSE);
+ }
+ }
+ else
+ {
+ if (!Config_getString("PROJECT_NAME").isEmpty())
+ {
+ ol.parseText(projPrefix+theTranslator->trDocumentation());
+ }
+ }
+ ol.endTitleHead(0,0);
+ // ol.newParagraph(); // FIXME:PARA
+ if (!Config_getString("PROJECT_NUMBER").isEmpty())
+ {
+ ol.startProjectNumber();
+ ol.parseDoc(defFileName,defLine,
+ Doxygen::mainPage,0,
+ Config_getString("PROJECT_NUMBER"),
+ TRUE,FALSE,0,
+ TRUE,FALSE);
+ ol.endProjectNumber();
+ }
+ if (Config_getBool("DISABLE_INDEX") && Doxygen::mainPage==0)
+ {
+ ol.writeQuickLinks(FALSE,HLI_Main);
+ }
+
+ if (Doxygen::mainPage)
+ {
+ Doxygen::insideMainPage=TRUE;
+ ol.parseDoc(defFileName,defLine,Doxygen::mainPage,0,
+ Doxygen::mainPage->documentation(),TRUE,FALSE
+ /*,Doxygen::mainPage->sectionDict*/);
+
+ if (!Config_getString("GENERATE_TAGFILE").isEmpty())
+ {
+ Doxygen::tagFile << " <compound kind=\"page\">" << endl
+ << " <name>"
+ << convertToXML(Doxygen::mainPage->name())
+ << "</name>" << endl
+ << " <title>"
+ << convertToXML(Doxygen::mainPage->title())
+ << "</title>" << endl
+ << " <filename>"
+ << convertToXML(Doxygen::mainPage->getOutputFileBase())
+ << "</filename>" << endl;
+
+ Doxygen::mainPage->writeDocAnchorsToTagFile();
+ Doxygen::tagFile << " </compound>" << endl;
+ }
+ 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.parseDoc(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
+ )
+ {
+ 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->name());
+
+ ol.writePageLink(pd->getOutputFileBase(),first);
+ first=FALSE;
+ }
+ }
+ }
+
+ 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 (Config_getBool("SHOW_DIRECTORIES") && documentedDirs>0)
+ {
+ ol.startIndexSection(isDirIndex);
+ ol.parseText(/*projPrefix+*/ theTranslator->trDirIndex());
+ ol.endIndexSection(isDirIndex);
+ }
+ 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->trCompoundIndex()
+ ));
+ ol.endIndexSection(isClassHierarchyIndex);
+ }
+ if (annotatedClasses>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 (Config_getBool("SHOW_DIRECTORIES") && documentedDirs>0)
+ {
+ ol.startIndexSection(isDirDocumentation);
+ ol.parseText(/*projPrefix+*/theTranslator->trDirDocumentation());
+ ol.endIndexSection(isDirDocumentation);
+ }
+ if (documentedNamespaces>0)
+ {
+ ol.startIndexSection(isNamespaceDocumentation);
+ ol.parseText(/*projPrefix+*/(fortranOpt?theTranslator->trModuleDocumentation():theTranslator->trNamespaceDocumentation()));
+ ol.endIndexSection(isNamespaceDocumentation);
+ }
+ if (annotatedClasses>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.startTextBlock();
+ ol.parseDoc(defFileName,defLine,Doxygen::mainPage,0,
+ Doxygen::mainPage->documentation(),FALSE,FALSE
+ );
+ ol.endTextBlock();
+ endFile(ol);
+ ol.enable(OutputGenerator::Man);
+ Doxygen::insideMainPage=FALSE;
+ }
+
+ ol.popGeneratorState();
+}
+
+
+