summaryrefslogtreecommitdiffstats
path: root/src/index.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/index.cpp')
-rw-r--r--src/index.cpp975
1 files changed, 975 insertions, 0 deletions
diff --git a/src/index.cpp b/src/index.cpp
new file mode 100644
index 0000000..d472542
--- /dev/null
+++ b/src/index.cpp
@@ -0,0 +1,975 @@
+/******************************************************************************
+ *
+ * $Id$
+ *
+ * Copyright (C) 1997-1999 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.
+ *
+ * All output generated with Doxygen is not covered by this license.
+ *
+ */
+
+#include <qtstream.h>
+#include <qdatetm.h>
+#include <qdir.h>
+#include <stdlib.h>
+
+#include "message.h"
+#include "index.h"
+#include "doxygen.h"
+#include "scanner.h"
+#include "code.h"
+#include "config.h"
+#include "filedef.h"
+#include "outputlist.h"
+#include "util.h"
+#include "groupdef.h"
+#include "language.h"
+
+//----------------------------------------------------------------------------
+
+// strips w from s iff s starts with w
+bool stripWord(QString &s,QString 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 :^)
+QString abbreviate(const char *s,const char *name)
+{
+ QString result=s;
+ QString start1=(QString)"The "+name+" class ";
+ QString start2=(QString)"The "+name+" widget ";
+ QString start3=(QString)"The "+name+" file ";
+ result=result.simplifyWhiteSpace();
+ // strip trailing .
+ if (result.length()>0 && result.at(result.length()-1)=='.')
+ result=result.left(result.length()-1);
+ bool found=FALSE;
+ found = found || stripWord(result,start1);
+ found = found || stripWord(result,start2);
+ found = found || stripWord(result,start3);
+ if (found)
+ {
+ bool found=FALSE;
+ found = found || stripWord(result,"is ");
+ found = found || stripWord(result,"provides ");
+ found = found || stripWord(result,"specifies ");
+ found = found || stripWord(result,"contains ");
+ found = found || stripWord(result,"represents ");
+ if (found)
+ {
+ stripWord(result,"a ");
+ stripWord(result,"an ");
+ stripWord(result,"the ");
+ }
+ }
+ if (result.length()>0)
+ {
+ int c=result[0];
+ if (c>='a' && c<='z') c+='A'-'a';
+ result[0]=c;
+ }
+ return result;
+}
+
+//----------------------------------------------------------------------------
+
+void initBaseClassHierarchy(BaseClassList *bcl)
+{
+ BaseClassListIterator bcli(*bcl);
+ for ( ; bcli.current(); ++bcli)
+ {
+ ClassDef *cd=bcli.current()->classDef;
+ if (cd->baseClasses()->count()==0) // no base classes => new root
+ {
+ initBaseClassHierarchy(cd->baseClasses());
+ }
+ cd->visited=FALSE;
+ }
+}
+
+//----------------------------------------------------------------------------
+
+void initClassHierarchy(ClassList *cl)
+{
+ ClassListIterator cli(*cl);
+ ClassDef *cd;
+ for ( ; (cd=cli.current()); ++cli)
+ {
+ cd->visited=FALSE;
+ initBaseClassHierarchy(cd->baseClasses());
+ }
+}
+
+//----------------------------------------------------------------------------
+
+bool hasVisibleRoot(BaseClassList *bcl)
+{
+ BaseClassListIterator bcli(*bcl);
+ for ( ; bcli.current(); ++bcli)
+ {
+ ClassDef *cd=bcli.current()->classDef;
+ if (cd->isVisibleExt()) return TRUE;
+ hasVisibleRoot(cd->baseClasses());
+ }
+ return FALSE;
+}
+
+//----------------------------------------------------------------------------
+
+void writeClassTree(OutputList &ol,BaseClassList *bcl,bool hideSuper)
+{
+ BaseClassListIterator bcli(*bcl);
+ bool started=FALSE;
+ for ( ; bcli.current() ; ++bcli)
+ {
+ ClassDef *cd=bcli.current()->classDef;
+ if (cd->isVisibleExt() && hasVisibleRoot(cd->baseClasses()))
+ {
+ if (!started)
+ {
+ ol.startIndexList();
+ started=TRUE;
+ }
+ //printf("Passed...\n");
+ if (cd->hasDocumentation() || cd->isReference())
+ {
+ ol.writeIndexItem(cd->getReference(),cd->classFile(),cd->name());
+ if (cd->isReference())
+ {
+ ol.startTypewriter();
+ ol.docify(" [external]");
+ ol.endTypewriter();
+ }
+ }
+ else
+ {
+ ol.writeIndexItem(0,0,cd->name());
+ }
+ if (!cd->visited && !hideSuper && cd->superClasses()->count()>0)
+ {
+ writeClassTree(ol,cd->superClasses(),cd->visited);
+ cd->visited=TRUE;
+ }
+ }
+ }
+ if (started) ol.endIndexList();
+}
+
+//----------------------------------------------------------------------------
+
+void writeClassHierarchy(OutputList &ol)
+{
+ initClassHierarchy(&classList);
+
+ bool started=FALSE;
+ ClassListIterator cli(classList);
+ for (;cli.current(); ++cli)
+ {
+ ClassDef *cd=cli.current();
+ if (!hasVisibleRoot(cd->baseClasses()))
+ {
+ if (cd->isVisibleExt())
+ {
+ if (!started)
+ {
+ ol.startIndexList();
+ started=TRUE;
+ }
+ if (cd->hasDocumentation() || cd->isReference())
+ {
+ ol.writeIndexItem(cd->getReference(),cd->classFile(),cd->name());
+ if (cd->isReference())
+ {
+ ol.startTypewriter();
+ ol.docify(" [external]");
+ ol.endTypewriter();
+ }
+ }
+ else
+ {
+ ol.writeIndexItem(0,0,cd->name());
+ }
+ }
+ if (!cd->visited && cd->superClasses()->count()>0)
+ {
+ writeClassTree(ol,cd->superClasses(),cd->visited);
+ cd->visited=TRUE;
+ }
+ }
+ }
+ if (started) ol.endIndexList();
+}
+
+//----------------------------------------------------------------------------
+
+int countClassHierarchy()
+{
+ initClassHierarchy(&classList);
+ int count=0;
+ ClassListIterator cli(classList);
+ for ( ; cli.current(); ++cli)
+ {
+ if (cli.current()->superClasses()->count()>0) count++;
+ }
+ return count;
+}
+
+//----------------------------------------------------------------------------
+
+void writeHierarchicalIndex(OutputList &ol)
+{
+ if (hierarchyClasses==0) return;
+ ol.disable(OutputGenerator::Man);
+ startFile(ol,"hierarchy","Hierarchical Index");
+ startTitle(ol);
+ parseDoc(ol,0,0,projectName+" "+theTranslator->trClassHierarchy());
+ endTitle(ol,0);
+ parseDoc(ol,0,0,theTranslator->trClassHierarchyDescription());
+ ol.newParagraph();
+ writeClassHierarchy(ol);
+ endFile(ol);
+ ol.enable(OutputGenerator::Man);
+}
+
+//----------------------------------------------------------------------------
+
+int countFileList()
+{
+ int count=0;
+ FileNameListIterator fnli(inputNameList);
+ FileName *fn;
+ for (;(fn=fnli.current());++fnli)
+ {
+ FileNameIterator fni(*fn);
+ FileDef *fd;
+ for (;(fd=fni.current());++fni)
+ {
+ if (fd->hasDocumentation()) count++;
+ }
+ }
+ return count;
+}
+
+//----------------------------------------------------------------------------
+
+void writeFileIndex(OutputList &ol)
+{
+ if (documentedFiles==0) return;
+ ol.disable(OutputGenerator::Man);
+ startFile(ol,"files","File Index");
+ startTitle(ol);
+ parseDoc(ol,0,0,projectName+" "+theTranslator->trFileList());
+ endTitle(ol,0);
+ ol.newParagraph();
+ parseDoc(ol,0,0,theTranslator->trFileListDescription(extractAllFlag));
+ ol.newParagraph();
+
+ ol.startIndexList();
+ FileName *fn=inputNameList.first();
+ while (fn)
+ {
+ FileDef *fd=fn->first();
+ while (fd)
+ {
+ if (fd->hasDocumentation() && !fd->isReference())
+ {
+ //ol.writeIndexItem(fd->getReference(),fd->diskName(),
+ // fd->name());
+ QString path;
+ if (fullPathNameFlag)
+ {
+ path=fd->getPath().copy();
+ // strip part of the path
+ if (path.left(stripFromPath.length())==stripFromPath)
+ path=path.right(path.length()-stripFromPath.length());
+ }
+
+ ol.writeStartAnnoItem("file",
+ fd->diskName(),
+ path,
+ fd->name()
+ );
+ ol.docify(" (");
+ if (fd->briefDescription())
+ {
+ OutputList briefOutput(&ol);
+ parseDoc(briefOutput,0,0,
+ abbreviate(fd->briefDescription(),fd->name()));
+ ol+=briefOutput;
+ }
+ else
+ {
+ ol.startEmphasis();
+ parseDoc(ol,0,0,theTranslator->trNoDescriptionAvailable());
+ ol.endEmphasis();
+ }
+ ol.docify(")");
+ ol.writeEndAnnoItem(fd->name());
+ }
+ fd=fn->next();
+ }
+ fn=inputNameList.next();
+ }
+ ol.endIndexList();
+ endFile(ol);
+ ol.enable(OutputGenerator::Man);
+}
+
+//----------------------------------------------------------------------------
+
+int countNamespaceList()
+{
+ int count=0;
+ NamespaceListIterator nli(namespaceList);
+ NamespaceDef *nd;
+ for (;(nd=nli.current());++nli)
+ {
+ if (nd->hasDocumentation()) count++;
+ }
+ return count;
+}
+
+//----------------------------------------------------------------------------
+
+void writeNamespaceIndex(OutputList &ol)
+{
+ if (documentedNamespaces==0) return;
+ ol.disable(OutputGenerator::Man);
+ startFile(ol,"namespaces","Namespace Index");
+ startTitle(ol);
+ parseDoc(ol,0,0,projectName+" "+theTranslator->trNamespaceList());
+ endTitle(ol,0);
+ ol.newParagraph();
+ parseDoc(ol,0,0,theTranslator->trNamespaceListDescription(extractAllFlag));
+ ol.newParagraph();
+
+ ol.startIndexList();
+ NamespaceDef *nd=namespaceList.first();
+ while (nd)
+ {
+ if (nd->hasDocumentation())
+ {
+ ol.writeStartAnnoItem("namespace",nd->namespaceFile(),0,nd->name());
+ ol.docify(" (");
+ if (nd->briefDescription())
+ {
+ OutputList briefOutput(&ol);
+ parseDoc(briefOutput,nd->name(),0,
+ abbreviate(nd->briefDescription(),nd->name()));
+ ol+=briefOutput;
+ }
+ else
+ {
+ ol.startEmphasis();
+ parseDoc(ol,0,0,theTranslator->trNoDescriptionAvailable());
+ ol.endEmphasis();
+ }
+ ol.docify(")");
+ ol.writeEndAnnoItem(nd->name());
+ }
+ nd=namespaceList.next();
+ }
+ ol.endIndexList();
+ endFile(ol);
+ ol.enable(OutputGenerator::Man);
+}
+
+//----------------------------------------------------------------------------
+
+int countAnnotatedClasses()
+{
+ int count=0;
+ //ClassDef *cd=classList.first();
+ ClassListIterator cli(classList);
+ ClassDef *cd;
+ for (;(cd=cli.current());++cli)
+ {
+ if (!cd->isReference() && cd->isVisible())
+ {
+ //printf("Annotated class %s\n",cd->name().data());
+ count++;
+ }
+ }
+ return count;
+}
+
+//----------------------------------------------------------------------
+
+void writeAnnotatedClassList(OutputList &ol)
+{
+ ol.startIndexList();
+ //ClassDef *cd=classList.first();
+ //while (cd)
+ ClassListIterator cli(classList);
+ ClassDef *cd;
+ for (;(cd=cli.current());++cli)
+ {
+ if (!cd->isReference() &&
+ //!cd->name().isEmpty() && cd->name()[0]!='@' &&
+ //(cd->protection()!=Private || extractPrivateFlag) &&
+ //(cd->hasDocumentation() || !hideClassFlag)
+ cd->isVisible()
+ )
+ {
+ QString type;
+ switch (cd->compoundType())
+ {
+ case ClassDef::Class: type="class"; break;
+ case ClassDef::Struct: type="struct"; break;
+ case ClassDef::Union: type="union"; break;
+ default: type="unknown"; break; // an error
+ }
+ ol.writeStartAnnoItem(type,cd->classFile(),0,cd->name());
+ ol.docify(" (");
+ if (cd->briefDescription())
+ {
+ OutputList briefOutput(&ol);
+ parseDoc(briefOutput,cd->name(),0,
+ abbreviate(cd->briefDescription(),cd->name()));
+ ol+=briefOutput;
+ }
+ else
+ {
+ ol.startEmphasis();
+ parseDoc(ol,0,0,theTranslator->trNoDescriptionAvailable());
+ ol.endEmphasis();
+ }
+ ol.docify(")");
+ ol.writeEndAnnoItem(cd->name());
+ }
+ cd=classList.next();
+ }
+ ol.endIndexList();
+}
+
+//----------------------------------------------------------------------------
+
+void writeAnnotatedIndex(OutputList &ol)
+{
+ if (annotatedClasses==0) return;
+
+ //if (classList.count()==0) return;
+ ol.disable(OutputGenerator::Man);
+ startFile(ol,"annotated","Annotated Index");
+ startTitle(ol);
+ parseDoc(ol,0,0,projectName+" "+theTranslator->trCompoundList());
+ endTitle(ol,0);
+ parseDoc(ol,0,0,theTranslator->trCompoundListDescription());
+ writeAnnotatedClassList(ol);
+ endFile(ol);
+ ol.enable(OutputGenerator::Man);
+}
+
+//----------------------------------------------------------------------------
+
+void writeMemberList(OutputList &ol)
+{
+ ol.startItemList();
+ MemberName *mn=memberNameList.first();
+ while (mn)
+ {
+ MemberDef *md=mn->first();
+ bool found=FALSE;
+ bool isFunc=FALSE;
+ while (md && !found)
+ {
+ ClassDef *cd;
+ if ((md->isFriend() || md->protection()!=Private || extractPrivateFlag) &&
+ !md->isReference() && md->hasDocumentation() &&
+ md->name()[0]!='@' && (cd=md->memberClass()) &&
+ cd->isVisible()
+ )
+ {
+ found=TRUE;
+ isFunc=md->isFunction();
+ }
+ md=mn->next();
+ }
+ if (found)
+ {
+ ol.writeListItem();
+ ol.docify(substituteClassNames(mn->memberName()));
+ if (isFunc) ol.docify("()");
+ ol.writeString("\n");
+
+ int count=0;
+ md=mn->first();
+ QString prevName;
+ while (md)
+ {
+ ClassDef *cd=md->memberClass();
+ if (cd && (md->isFriend() || md->protection()!=Private || extractPrivateFlag) &&
+ !md->isReference() && md->hasDocumentation() &&
+ prevName!=cd->name() &&
+ cd->isVisible()
+ )
+ {
+ if (count==0)
+ ol.docify(": ");
+ else
+ ol.docify(", ");
+ ol.writeObjectLink(cd->getReference(),cd->classFile(),md->anchor(),
+ cd->name());
+ count++;
+ prevName=cd->name();
+ }
+ md=mn->next();
+ }
+ }
+ mn=memberNameList.next();
+ }
+ ol.endItemList();
+}
+
+//----------------------------------------------------------------------------
+
+int countMemberList()
+{
+ int count=0;
+ MemberName *mn=memberNameList.first();
+ while (mn)
+ {
+ MemberDef *md=mn->first();
+ bool found=FALSE;
+ MemberDef *otherMd=0;
+ ClassDef *cd;
+ while (md && !found)
+ {
+ if ((md->isFriend() || md->protection()!=Private || extractPrivateFlag) &&
+ !md->isReference() && !md->isRelated() && md->hasDocumentation() &&
+ md->name()[0]!='@' && (cd=md->memberClass()) && cd->isVisible())
+ otherMd=md;
+ if ((md->isFriend() || md->protection()!=Private || extractPrivateFlag) &&
+ !md->isReference() && md->isRelated() && md->hasDocumentation() &&
+ md->name()[0]!='@' && (cd=md->memberClass()) && cd->isVisible())
+ found=TRUE;
+ else
+ md=mn->next();
+ }
+ if (found || otherMd) count++;
+ mn=memberNameList.next();
+ }
+ return count;
+}
+
+//----------------------------------------------------------------------------
+
+void writeMemberIndex(OutputList &ol)
+{
+ if (memberNameList.count()==0) return;
+ ol.disable(OutputGenerator::Man);
+ ol.disable(OutputGenerator::Latex);
+ startFile(ol,"functions","Compound Member Index");
+ startTitle(ol);
+ parseDoc(ol,0,0,projectName+" "+theTranslator->trCompoundMembers());
+ endTitle(ol,0);
+ parseDoc(ol,0,0,theTranslator->trCompoundMembersDescription(extractAllFlag));
+ writeMemberList(ol);
+ endFile(ol);
+ ol.enable(OutputGenerator::Latex);
+ ol.enable(OutputGenerator::Man);
+}
+
+//----------------------------------------------------------------------------
+
+void writeFunctionList(OutputList &ol)
+{
+ ol.startItemList();
+ MemberName *mn=functionNameList.first();
+ while (mn)
+ {
+ MemberDef *md=mn->first();
+ bool found=FALSE;
+ while (md && !found)
+ {
+ FileDef *fd=md->getFileDef() ? md->getFileDef() : md->getFileDec();
+ bool hasDocs =
+ (md->getFileDef() && md->getFileDef()->hasDocumentation()) ||
+ (md->getFileDec() && md->getFileDec()->hasDocumentation());
+
+ if (fd && hasDocs &&
+ !md->isReference() &&
+ md->hasDocumentation() &&
+ md->name()[0]!='@') found=TRUE;
+ else
+ md=mn->next();
+ }
+ if (found) // function is documented
+ {
+ ol.writeListItem();
+ ol.docify(md->name());
+ if (md->isFunction()) ol.docify("()");
+ ol.writeString("\n");
+
+ int count=0;
+ md=mn->first();
+ QString prevName;
+ while (md)
+ {
+ FileDef *fd=md->getFileDef() ? md->getFileDef() : md->getFileDec();
+ bool hasDocs =
+ (md->getFileDef() && md->getFileDef()->hasDocumentation()) ||
+ (md->getFileDec() && md->getFileDec()->hasDocumentation());
+ if (fd && hasDocs &&
+ !md->isReference() &&
+ md->hasDocumentation() &&
+ md->name()[0]!='@' &&
+ prevName!=fd->name())
+ {
+ if (count==0)
+ ol.docify(": ");
+ else
+ ol.docify(", ");
+ QString baseName=fd->name().copy();
+ //int s;
+ //if ((s=baseName.findRev("/"))!=-1)
+ // baseName=baseName.right(baseName.length()-s-1);
+ ol.writeObjectLink(fd->getReference(),
+ fd->diskName(),md->anchor(), baseName);
+ count++;
+ prevName=fd->name();
+ }
+ md=mn->next();
+ }
+ }
+ mn=functionNameList.next();
+ }
+ ol.endItemList();
+}
+
+//----------------------------------------------------------------------------
+
+int countFunctionList()
+{
+ int count=0;
+ MemberName *mn=functionNameList.first();
+ while (mn)
+ {
+ MemberDef *md=mn->first();
+ FileDef *fd;
+ bool found=FALSE;
+ while (md && !found)
+ {
+ if (!md->isReference() && md->hasDocumentation() &&
+ md->name()[0]!='@' &&
+ (((fd=md->getFileDef()) && fd->hasDocumentation())
+ ||
+ ((fd=md->getFileDec()) && fd->hasDocumentation())
+ )
+ )
+ found=TRUE;
+ else
+ md=mn->next();
+ }
+ if (found) count++;
+ mn=functionNameList.next();
+ }
+ return count;
+}
+
+//----------------------------------------------------------------------------
+
+void writeFunctionIndex(OutputList &ol)
+{
+ if (documentedFunctions==0) return;
+ ol.disable(OutputGenerator::Man);
+ ol.disable(OutputGenerator::Latex);
+ startFile(ol,"globals","File Member Index");
+ startTitle(ol);
+ parseDoc(ol,0,0,projectName+" "+theTranslator->trFileMembers());
+ endTitle(ol,0);
+ parseDoc(ol,0,0,theTranslator->trFileMembersDescription(extractAllFlag));
+ writeFunctionList(ol);
+ endFile(ol);
+ ol.enable(OutputGenerator::Latex);
+ ol.enable(OutputGenerator::Man);
+}
+
+//----------------------------------------------------------------------------
+
+void writeHeaderFileList(OutputList &ol)
+{
+ if (includeFiles.count()>0)
+ {
+ ol.startItemList();
+ FileDef *fd=includeFiles.first();
+ while (fd)
+ {
+ ol.writeListItem();
+ QString path;
+ if (fullPathNameFlag)
+ {
+ path=fd->getPath().copy();
+ // strip part of the path
+ if (path.left(stripFromPath.length())==stripFromPath)
+ path=path.right(path.length()-stripFromPath.length());
+ }
+ if (!path.isEmpty()) ol.docify(path);
+ ol.writeObjectLink(0,fd->includeName(),0,fd->name());
+ ol.writeString("\n");
+ fd=includeFiles.next();
+ }
+ ol.endItemList();
+ }
+}
+
+//----------------------------------------------------------------------------
+
+void writeHeaderIndex(OutputList &ol)
+{
+ if (includeFiles.count()==0) return;
+ ol.disable(OutputGenerator::Man);
+ ol.disable(OutputGenerator::Latex);
+ startFile(ol,"headers","Header File Index");
+ startTitle(ol);
+ parseDoc(ol,0,0,projectName+" "+theTranslator->trHeaderFiles());
+ endTitle(ol,0);
+ parseDoc(ol,0,0,theTranslator->trHeaderFilesDescription());
+ writeHeaderFileList(ol);
+ endFile(ol);
+ ol.enable(OutputGenerator::Latex);
+ ol.enable(OutputGenerator::Man);
+}
+
+//----------------------------------------------------------------------------
+
+void writeExampleIndex(OutputList &ol)
+{
+ if (exampleList.count()==0) return;
+ ol.disable(OutputGenerator::Man);
+ startFile(ol,"examples","Example Index");
+ startTitle(ol);
+ parseDoc(ol,0,0,projectName+" "+theTranslator->trExamples());
+ endTitle(ol,0);
+ parseDoc(ol,0,0,theTranslator->trExamplesDescription());
+ ol.startIndexList();
+ PageInfo *pi=exampleList.first();
+ while (pi)
+ {
+ ol.writeListItem();
+ QString n=convertSlashes(pi->name,TRUE)+"-example";
+ if (!pi->title.isEmpty())
+ {
+ ol.writeObjectLink(0,n,0,pi->title);
+ }
+ else
+ {
+ ol.writeObjectLink(0,n,0,pi->name);
+ }
+ ol.writeString("\n");
+ pi=exampleList.next();
+ }
+ ol.endIndexList();
+ endFile(ol);
+ ol.enable(OutputGenerator::Man);
+}
+
+//----------------------------------------------------------------------------
+
+void writePageIndex(OutputList &ol)
+{
+ if (pageList.count()==0) return;
+ ol.disable(OutputGenerator::Man);
+ startFile(ol,"pages","Page Index");
+ startTitle(ol);
+ ol.docify(projectName+" "+theTranslator->trRelatedPages());
+ endTitle(ol,0);
+ parseDoc(ol,0,0,theTranslator->trRelatedPagesDescription());
+ ol.startIndexList();
+ PageInfo *pi=pageList.first();
+ while (pi)
+ {
+ QString pageName;
+ if (caseSensitiveNames)
+ pageName=pi->name.copy();
+ else
+ pageName=pi->name.lower();
+ ol.writeListItem();
+ ol.writeObjectLink(0,pageName,0,pi->name);
+ ol.writeString("\n");
+ pi=pageList.next();
+ }
+ ol.endIndexList();
+ endFile(ol);
+ ol.enable(OutputGenerator::Man);
+}
+
+//----------------------------------------------------------------------------
+
+int countGroupList()
+{
+ int count=0;
+ GroupListIterator gli(groupList);
+ GroupDef *gd;
+ for (;(gd=gli.current());++gli)
+ {
+ if (gd->countMembers()>0) count++;
+ gd=groupList.next();
+ }
+ return count;
+}
+
+//----------------------------------------------------------------------------
+
+void writeGroupList(OutputList &ol)
+{
+ ol.startDescription();
+ GroupListIterator gli(groupList);
+ GroupDef *gd;
+ for (;(gd=gli.current());++gli)
+ {
+ if (gd->countMembers()>0)
+ {
+ ol.startDescItem();
+ ol.startTextLink(gd->groupFile(),0);
+ parseDoc(ol,0,0,gd->groupTitle());
+ ol.endTextLink();
+ ol.endDescItem();
+ parseDoc(ol,0,0,gd->briefDescription());
+ ol.newParagraph();
+ }
+ }
+ ol.endDescription();
+}
+
+//----------------------------------------------------------------------------
+
+void writeGroupIndex(OutputList &ol)
+{
+ if (documentedGroups==0) return;
+ ol.disable(OutputGenerator::Man);
+ startFile(ol,"modules","Module Index");
+ startTitle(ol);
+ parseDoc(ol,0,0,projectName+" "+theTranslator->trModules());
+ endTitle(ol,0);
+ parseDoc(ol,0,0,theTranslator->trModulesDescription());
+ writeGroupList(ol);
+ endFile(ol);
+ ol.enable(OutputGenerator::Man);
+}
+
+void writeIndex(OutputList &ol)
+{
+ // save old generator state
+ bool manEnabled = ol.isEnabled(OutputGenerator::Man);
+ bool texEnabled = ol.isEnabled(OutputGenerator::Latex);
+ bool htmEnabled = ol.isEnabled(OutputGenerator::Html);
+
+ QString projPrefix;
+ if (!projectName.isEmpty())
+ {
+ projPrefix=projectName+" ";
+ }
+ // write HTML index
+ ol.disable(OutputGenerator::Man);
+ ol.disable(OutputGenerator::Latex);
+ ol.startFile("index","Main Index",FALSE);
+ if (!noIndexFlag) writeQuickLinks(ol,TRUE);
+ ol.startTitleHead();
+ parseDoc(ol,0,0,projPrefix+theTranslator->trDocumentation());
+ ol.endTitleHead(0);
+ ol.newParagraph();
+ if (!projectNumber.isEmpty())
+ {
+ ol.startProjectNumber();
+ parseDoc(ol,0,0,projectNumber);
+ ol.endProjectNumber();
+ }
+ if (noIndexFlag) writeQuickLinks(ol,FALSE);
+ endFile(ol);
+ ol.disable(OutputGenerator::Html);
+
+ // write LaTeX index
+ ol.enable(OutputGenerator::Latex);
+ ol.startFile("refman",0,FALSE);
+ ol.startIndexSection(isTitlePageStart);
+ parseDoc(ol,0,0,projPrefix+theTranslator->trReferenceManual());
+ if (!projectNumber.isEmpty())
+ {
+ ol.startProjectNumber();
+ parseDoc(ol,0,0,projectNumber);
+ ol.endProjectNumber();
+ }
+ ol.endIndexSection(isTitlePageStart);
+ ol.startIndexSection(isTitlePageAuthor);
+ parseDoc(ol,0,0,theTranslator->trGeneratedBy());
+ ol.endIndexSection(isTitlePageAuthor);
+ if (documentedGroups>0)
+ {
+ ol.startIndexSection(isModuleIndex);
+ parseDoc(ol,0,0,projPrefix+theTranslator->trModuleIndex());
+ ol.endIndexSection(isModuleIndex);
+ }
+ if (hierarchyClasses>0)
+ {
+ ol.startIndexSection(isClassHierarchyIndex);
+ parseDoc(ol,0,0,projPrefix+theTranslator->trHierarchicalIndex());
+ ol.endIndexSection(isClassHierarchyIndex);
+ }
+ if (annotatedClasses>0)
+ {
+ ol.startIndexSection(isCompoundIndex);
+ parseDoc(ol,0,0,projPrefix+theTranslator->trCompoundIndex());
+ ol.endIndexSection(isCompoundIndex);
+ }
+ if (documentedFiles>0)
+ {
+ ol.startIndexSection(isFileIndex);
+ parseDoc(ol,0,0,projPrefix+theTranslator->trFileIndex());
+ ol.endIndexSection(isFileIndex);
+ }
+ if (documentedGroups>0)
+ {
+ ol.startIndexSection(isModuleDocumentation);
+ parseDoc(ol,0,0,projPrefix+theTranslator->trModuleDocumentation());
+ ol.endIndexSection(isModuleDocumentation);
+ }
+ if (annotatedClasses>0)
+ {
+ ol.startIndexSection(isClassDocumentation);
+ parseDoc(ol,0,0,projPrefix+theTranslator->trClassDocumentation());
+ ol.endIndexSection(isClassDocumentation);
+ }
+ if (documentedFiles>0)
+ {
+ ol.startIndexSection(isFileDocumentation);
+ parseDoc(ol,0,0,projPrefix+theTranslator->trFileDocumentation());
+ ol.endIndexSection(isFileDocumentation);
+ }
+ if (exampleList.count()>0)
+ {
+ ol.startIndexSection(isExampleDocumentation);
+ parseDoc(ol,0,0,projPrefix+theTranslator->trExampleDocumentation());
+ ol.endIndexSection(isExampleDocumentation);
+ }
+ if (pageList.count()>0)
+ {
+ ol.startIndexSection(isPageDocumentation);
+ parseDoc(ol,0,0,projPrefix+theTranslator->trPageDocumentation());
+ ol.endIndexSection(isPageDocumentation);
+ }
+ ol.endIndexSection(isEndIndex);
+ endFile(ol);
+
+ // restore generator state
+ if (manEnabled) ol.enable(OutputGenerator::Man);
+ else ol.disable(OutputGenerator::Man);
+ if (texEnabled) ol.enable(OutputGenerator::Latex);
+ else ol.disable(OutputGenerator::Latex);
+ if (htmEnabled) ol.enable(OutputGenerator::Html);
+ else ol.disable(OutputGenerator::Html);
+}
generated by cgit v0.12 at 2024-11-01 15:40:37 (GMT)