summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/context.cpp1290
-rw-r--r--src/context.h112
-rw-r--r--src/groupdef.cpp7
-rw-r--r--src/groupdef.h3
-rw-r--r--src/template.cpp164
-rw-r--r--src/template.h23
-rw-r--r--src/translator_en.h2
7 files changed, 1055 insertions, 546 deletions
diff --git a/src/context.cpp b/src/context.cpp
index 8b3785d..5516729 100644
--- a/src/context.cpp
+++ b/src/context.cpp
@@ -1,3 +1,18 @@
+/******************************************************************************
+ *
+ * Copyright (C) 1997-2014 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.
+ *
+ */
+
#include "context.h"
#include "config.h"
#include "index.h"
@@ -24,6 +39,7 @@
#include "parserintf.h"
#include "portable.h"
#include "arguments.h"
+#include "groupdef.h"
// TODO: pass the current file to Dot*::writeGraph, so the user can put dot graphs in other
// files as well
@@ -144,6 +160,10 @@ class GenericNodeListContext : public TemplateListIntf
{
m_children.setAutoDelete(TRUE);
}
+ static GenericNodeListContext *alloc()
+ {
+ return new GenericNodeListContext;
+ }
// TemplateListIntf methods
int count() const
@@ -770,6 +790,11 @@ class TranslateContext::Private : public PropertyMapper
bool extractAll = Config_getBool("EXTRACT_ALL");
return theTranslator->trFileListDescription(extractAll);
}
+ TemplateVariant modulesDescription() const
+ {
+ bool extractAll = Config_getBool("EXTRACT_ALL");
+ return theTranslator->trModulesListDescription(extractAll);
+ }
TemplateVariant directories() const
{
return theTranslator->trDirectories();
@@ -888,6 +913,8 @@ class TranslateContext::Private : public PropertyMapper
addProperty("fileListDescription",this,&Private::fileListDescription);
//%% string directories
addProperty("directories", this,&Private::directories);
+ //%% string moduleDescript
+ addProperty("modulesDescription", this,&Private::modulesDescription);
m_javaOpt = Config_getBool("OPTIMIZE_OUTPUT_JAVA");
m_fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN");
@@ -1745,7 +1772,7 @@ class ClassContext::Private : public DefinitionContext<ClassContext::Private>
{
if (!m_cache.classes)
{
- NestedClassListContext *classList = NestedClassListContext::alloc();
+ TemplateList *classList = TemplateList::alloc();
if (m_classDef->getClassSDict())
{
ClassSDict::Iterator sdi(*m_classDef->getClassSDict());
@@ -1754,7 +1781,7 @@ class ClassContext::Private : public DefinitionContext<ClassContext::Private>
{
if (cd->visibleInParentsDeclList())
{
- classList->append(cd);
+ classList->append(ClassContext::alloc(cd));
}
}
}
@@ -1975,7 +2002,7 @@ class ClassContext::Private : public DefinitionContext<ClassContext::Private>
SharedPtr<InheritanceListContext> inheritedByList;
ScopedPtr<DotClassGraph> classGraph;
ScopedPtr<DotClassGraph> collaborationGraph;
- SharedPtr<NestedClassListContext> classes;
+ SharedPtr<TemplateList> classes;
SharedPtr<MemberListInfoContext> publicTypes;
SharedPtr<MemberListInfoContext> publicMethods;
SharedPtr<MemberListInfoContext> publicStaticMethods;
@@ -2100,7 +2127,7 @@ class NamespaceContext::Private : public DefinitionContext<NamespaceContext::Pri
{
if (!m_cache.classes)
{
- NestedClassListContext *classList = NestedClassListContext::alloc();
+ TemplateList *classList = TemplateList::alloc();
if (m_namespaceDef->getClassSDict())
{
ClassSDict::Iterator sdi(*m_namespaceDef->getClassSDict());
@@ -2109,7 +2136,7 @@ class NamespaceContext::Private : public DefinitionContext<NamespaceContext::Pri
{
if (cd->visibleInParentsDeclList())
{
- classList->append(cd);
+ classList->append(ClassContext::alloc(cd));
}
}
}
@@ -2121,7 +2148,7 @@ class NamespaceContext::Private : public DefinitionContext<NamespaceContext::Pri
{
if (!m_cache.namespaces)
{
- NestedNamespaceListContext *namespaceList = NestedNamespaceListContext::alloc();
+ TemplateList *namespaceList = TemplateList::alloc();
if (m_namespaceDef->getNamespaceSDict())
{
NamespaceSDict::Iterator sdi(*m_namespaceDef->getNamespaceSDict());
@@ -2130,7 +2157,7 @@ class NamespaceContext::Private : public DefinitionContext<NamespaceContext::Pri
{
if (nd->isLinkable() && !nd->isConstantGroup())
{
- namespaceList->append(nd);
+ namespaceList->append(NamespaceContext::alloc(nd));
}
}
}
@@ -2142,7 +2169,7 @@ class NamespaceContext::Private : public DefinitionContext<NamespaceContext::Pri
{
if (!m_cache.constantgroups)
{
- NestedNamespaceListContext *namespaceList = NestedNamespaceListContext::alloc();
+ TemplateList *namespaceList = TemplateList::alloc();
if (m_namespaceDef->getNamespaceSDict())
{
NamespaceSDict::Iterator sdi(*m_namespaceDef->getNamespaceSDict());
@@ -2151,7 +2178,7 @@ class NamespaceContext::Private : public DefinitionContext<NamespaceContext::Pri
{
if (nd->isLinkable() && nd->isConstantGroup())
{
- namespaceList->append(nd);
+ namespaceList->append(NamespaceContext::alloc(nd));
}
}
}
@@ -2189,9 +2216,11 @@ class NamespaceContext::Private : public DefinitionContext<NamespaceContext::Pri
}
TemplateVariant functions() const
{
- // TODO: Fortran: trSubprograms()
- // TODO: VHDL: VhdlDocGen::trFunctionAndProc()
- return getMemberList(m_cache.functions,MemberListType_decFuncMembers,theTranslator->trFunctions());
+ QCString title = theTranslator->trFunctions();
+ SrcLangExt lang = m_namespaceDef->getLanguage();
+ if (lang==SrcLangExt_Fortran) title=theTranslator->trSubprograms();
+ else if (lang==SrcLangExt_VHDL) title=VhdlDocGen::trFunctionAndProc();
+ return getMemberList(m_cache.functions,MemberListType_decFuncMembers,title);
}
TemplateVariant variables() const
{
@@ -2222,8 +2251,10 @@ class NamespaceContext::Private : public DefinitionContext<NamespaceContext::Pri
}
TemplateVariant detailedFunctions() const
{
- // TODO: Fortran: trSubprogramDocumentation()
- return getMemberList(m_cache.detailedFunctions,MemberListType_docFuncMembers,theTranslator->trFunctionDocumentation());
+ QCString title = theTranslator->trFunctionDocumentation();
+ SrcLangExt lang = m_namespaceDef->getLanguage();
+ if (lang==SrcLangExt_Fortran) title=theTranslator->trSubprogramDocumentation();
+ return getMemberList(m_cache.detailedFunctions,MemberListType_docFuncMembers,title);
}
TemplateVariant detailedVariables() const
{
@@ -2233,7 +2264,7 @@ class NamespaceContext::Private : public DefinitionContext<NamespaceContext::Pri
{
if (!m_cache.inlineClasses)
{
- NestedClassListContext *classList = NestedClassListContext::alloc();
+ TemplateList *classList = TemplateList::alloc();
if (m_namespaceDef->getClassSDict())
{
ClassSDict::Iterator sdi(*m_namespaceDef->getClassSDict());
@@ -2245,7 +2276,7 @@ class NamespaceContext::Private : public DefinitionContext<NamespaceContext::Pri
cd->isEmbeddedInOuterScope() &&
cd->partOfGroups()==0)
{
- classList->append(cd);
+ classList->append(ClassContext::alloc(cd));
}
}
}
@@ -2257,9 +2288,9 @@ class NamespaceContext::Private : public DefinitionContext<NamespaceContext::Pri
NamespaceDef *m_namespaceDef;
struct Cachable
{
- SharedPtr<NestedClassListContext> classes;
- SharedPtr<NestedNamespaceListContext> namespaces;
- SharedPtr<NestedNamespaceListContext> constantgroups;
+ SharedPtr<TemplateList> classes;
+ SharedPtr<TemplateList> namespaces;
+ SharedPtr<TemplateList> constantgroups;
SharedPtr<MemberListInfoContext> typedefs;
SharedPtr<MemberListInfoContext> enums;
SharedPtr<MemberListInfoContext> functions;
@@ -2269,7 +2300,7 @@ class NamespaceContext::Private : public DefinitionContext<NamespaceContext::Pri
SharedPtr<MemberListInfoContext> detailedEnums;
SharedPtr<MemberListInfoContext> detailedFunctions;
SharedPtr<MemberListInfoContext> detailedVariables;
- SharedPtr<NestedClassListContext> inlineClasses;
+ SharedPtr<TemplateList> inlineClasses;
};
mutable Cachable m_cache;
};
@@ -2455,7 +2486,7 @@ class FileContext::Private : public DefinitionContext<FileContext::Private>
{
if (!m_cache.classes)
{
- NestedClassListContext *classList = NestedClassListContext::alloc();
+ TemplateList *classList = TemplateList::alloc();
if (m_fileDef->getClassSDict())
{
ClassSDict::Iterator sdi(*m_fileDef->getClassSDict());
@@ -2464,7 +2495,7 @@ class FileContext::Private : public DefinitionContext<FileContext::Private>
{
if (cd->visibleInParentsDeclList())
{
- classList->append(cd);
+ classList->append(ClassContext::alloc(cd));
}
}
}
@@ -2476,7 +2507,7 @@ class FileContext::Private : public DefinitionContext<FileContext::Private>
{
if (!m_cache.namespaces)
{
- NestedNamespaceListContext *namespaceList = NestedNamespaceListContext::alloc();
+ TemplateList *namespaceList = TemplateList::alloc();
if (m_fileDef->getNamespaceSDict())
{
NamespaceSDict::Iterator sdi(*m_fileDef->getNamespaceSDict());
@@ -2485,7 +2516,7 @@ class FileContext::Private : public DefinitionContext<FileContext::Private>
{
if (nd->isLinkable() && !nd->isConstantGroup())
{
- namespaceList->append(nd);
+ namespaceList->append(NamespaceContext::alloc(nd));
}
}
}
@@ -2497,7 +2528,7 @@ class FileContext::Private : public DefinitionContext<FileContext::Private>
{
if (!m_cache.constantgroups)
{
- NestedNamespaceListContext *namespaceList = NestedNamespaceListContext::alloc();
+ TemplateList *namespaceList = TemplateList::alloc();
if (m_fileDef->getNamespaceSDict())
{
NamespaceSDict::Iterator sdi(*m_fileDef->getNamespaceSDict());
@@ -2506,7 +2537,7 @@ class FileContext::Private : public DefinitionContext<FileContext::Private>
{
if (nd->isLinkable() && nd->isConstantGroup())
{
- namespaceList->append(nd);
+ namespaceList->append(NamespaceContext::alloc(nd));
}
}
}
@@ -2548,9 +2579,11 @@ class FileContext::Private : public DefinitionContext<FileContext::Private>
}
TemplateVariant functions() const
{
- // TODO: Fortran: trSubprograms()
- // TODO: VHDL: VhdlDocGen::trFunctionAndProc()
- return getMemberList(m_cache.functions,MemberListType_decFuncMembers,theTranslator->trFunctions());
+ QCString title = theTranslator->trFunctions();
+ SrcLangExt lang = m_fileDef->getLanguage();
+ if (lang==SrcLangExt_Fortran) title=theTranslator->trSubprograms();
+ else if (lang==SrcLangExt_VHDL) title=VhdlDocGen::trFunctionAndProc();
+ return getMemberList(m_cache.functions,MemberListType_decFuncMembers,title);
}
TemplateVariant variables() const
{
@@ -2585,8 +2618,10 @@ class FileContext::Private : public DefinitionContext<FileContext::Private>
}
TemplateVariant detailedFunctions() const
{
- // TODO: Fortran: trSubprogramDocumentation()
- return getMemberList(m_cache.detailedFunctions,MemberListType_docFuncMembers,theTranslator->trFunctionDocumentation());
+ QCString title = theTranslator->trFunctionDocumentation();
+ SrcLangExt lang = m_fileDef->getLanguage();
+ if (lang==SrcLangExt_Fortran) title=theTranslator->trSubprogramDocumentation();
+ return getMemberList(m_cache.detailedFunctions,MemberListType_docFuncMembers,title);
}
TemplateVariant detailedVariables() const
{
@@ -2596,7 +2631,7 @@ class FileContext::Private : public DefinitionContext<FileContext::Private>
{
if (!m_cache.inlineClasses)
{
- NestedClassListContext *classList = NestedClassListContext::alloc();
+ TemplateList *classList = TemplateList::alloc();
if (m_fileDef->getClassSDict())
{
ClassSDict::Iterator sdi(*m_fileDef->getClassSDict());
@@ -2608,7 +2643,7 @@ class FileContext::Private : public DefinitionContext<FileContext::Private>
cd->isEmbeddedInOuterScope() &&
cd->partOfGroups()==0)
{
- classList->append(cd);
+ classList->append(ClassContext::alloc(cd));
}
}
}
@@ -2629,9 +2664,9 @@ class FileContext::Private : public DefinitionContext<FileContext::Private>
ScopedPtr<DotInclDepGraph> includeGraph;
ScopedPtr<DotInclDepGraph> includedByGraph;
ScopedPtr<TemplateVariant> sources;
- SharedPtr<NestedClassListContext> classes;
- SharedPtr<NestedNamespaceListContext> namespaces;
- SharedPtr<NestedNamespaceListContext> constantgroups;
+ SharedPtr<TemplateList> classes;
+ SharedPtr<TemplateList> namespaces;
+ SharedPtr<TemplateList> constantgroups;
SharedPtr<MemberListInfoContext> macros;
SharedPtr<MemberListInfoContext> typedefs;
SharedPtr<MemberListInfoContext> enums;
@@ -2643,7 +2678,7 @@ class FileContext::Private : public DefinitionContext<FileContext::Private>
SharedPtr<MemberListInfoContext> detailedEnums;
SharedPtr<MemberListInfoContext> detailedFunctions;
SharedPtr<MemberListInfoContext> detailedVariables;
- SharedPtr<NestedClassListContext> inlineClasses;
+ SharedPtr<TemplateList> inlineClasses;
};
mutable Cachable m_cache;
};
@@ -3977,9 +4012,48 @@ class ModuleContext::Private : public DefinitionContext<ModuleContext::Private>
public:
Private(GroupDef *gd) : DefinitionContext<ModuleContext::Private>(gd) , m_groupDef(gd)
{
- addProperty("title",this,&Private::title);
- addProperty("highlight",this,&Private::highlight);
- addProperty("subhighlight",this,&Private::subHighlight);
+ addProperty("title", this,&Private::title);
+ addProperty("highlight", this,&Private::highlight);
+ addProperty("subhighlight", this,&Private::subHighlight);
+ addProperty("hasGroupGraph", this,&Private::hasGroupGraph);
+ addProperty("groupGraph", this,&Private::groupGraph);
+ addProperty("hasDetails", this,&Private::hasDetails);
+ addProperty("modules", this,&Private::modules);
+ addProperty("dirs", this,&Private::dirs);
+ addProperty("files", this,&Private::files);
+ addProperty("namespaces", this,&Private::namespaces);
+ addProperty("classes", this,&Private::classes);
+ addProperty("constantgroups", this,&Private::constantgroups);
+ addProperty("examples", this,&Private::examples);
+ addProperty("macros", this,&Private::macros);
+ addProperty("typedefs", this,&Private::typedefs);
+ addProperty("enums", this,&Private::enums);
+ addProperty("enumvalues", this,&Private::enumValues);
+ addProperty("functions", this,&Private::functions);
+ addProperty("variables", this,&Private::variables);
+ addProperty("signals", this,&Private::signals);
+ addProperty("publicSlots", this,&Private::publicSlots);
+ addProperty("protectedSlots", this,&Private::protectedSlots);
+ addProperty("privateSlots", this,&Private::privateSlots);
+ addProperty("events", this,&Private::events);
+ addProperty("properties", this,&Private::properties);
+ addProperty("friends", this,&Private::friends);
+ addProperty("memberGroups", this,&Private::memberGroups);
+ addProperty("detailedMacros", this,&Private::detailedMacros);
+ addProperty("detailedTypedefs", this,&Private::detailedTypedefs);
+ addProperty("detailedEnums", this,&Private::detailedEnums);
+ addProperty("detailedEnumValues", this,&Private::detailedEnumValues);
+ addProperty("detailedFunctions", this,&Private::detailedFunctions);
+ addProperty("detailedVariables", this,&Private::detailedVariables);
+ addProperty("detailedSignals", this,&Private::detailedSignals);
+ addProperty("detailedPublicSlots", this,&Private::detailedPublicSlots);
+ addProperty("detailedProtectedSlots", this,&Private::detailedProtectedSlots);
+ addProperty("detailedPrivateSlots", this,&Private::detailedPrivateSlots);
+ addProperty("detailedEvents", this,&Private::detailedEvents);
+ addProperty("detailedProperties", this,&Private::detailedProperties);
+ addProperty("detailedFriends", this,&Private::detailedFriends);
+ addProperty("inlineClasses", this,&Private::inlineClasses);
+ addProperty("compoundType", this,&Private::compoundType);
}
TemplateVariant title() const
{
@@ -3993,8 +4067,423 @@ class ModuleContext::Private : public DefinitionContext<ModuleContext::Private>
{
return TemplateVariant("");
}
+ DotGroupCollaboration *getGroupGraph() const
+ {
+ if (!m_cache.groupGraph)
+ {
+ m_cache.groupGraph.reset(new DotGroupCollaboration(m_groupDef));
+ }
+ return m_cache.groupGraph.get();
+ }
+ TemplateVariant hasGroupGraph() const
+ {
+ bool result=FALSE;
+ static bool haveDot = Config_getBool("HAVE_DOT");
+ static bool groupGraphs = Config_getBool("GROUP_GRAPHS");
+ if (haveDot && groupGraphs)
+ {
+ DotGroupCollaboration *graph = getGroupGraph();
+ result = !graph->isTrivial();
+ }
+ return result;
+ }
+ TemplateVariant groupGraph() const
+ {
+ QGString result;
+ static bool haveDot = Config_getBool("HAVE_DOT");
+ static bool groupGraphs = Config_getBool("GROUP_GRAPHS");
+ if (haveDot && groupGraphs)
+ {
+ DotGroupCollaboration *graph = getGroupGraph();
+ FTextStream t(&result);
+ graph->writeGraph(t,BITMAP,
+ g_globals.outputDir,
+ g_globals.outputDir+portable_pathSeparator()+m_groupDef->getOutputFileBase()+Doxygen::htmlFileExtension,
+ relPathAsString(),
+ TRUE,
+ g_globals.dynSectionId);
+ }
+ g_globals.dynSectionId++;
+ return TemplateVariant(result.data(),TRUE);
+ }
+ TemplateVariant hasDetails() const
+ {
+ return m_groupDef->hasDetailedDescription();
+ }
+ TemplateVariant modules() const
+ {
+ if (!m_cache.modules)
+ {
+ TemplateList *moduleList = TemplateList::alloc();
+ if (m_groupDef->getSubGroups())
+ {
+ GroupListIterator gli(*m_groupDef->getSubGroups());
+ GroupDef *gd;
+ for (gli.toFirst();(gd=gli.current());++gli)
+ {
+ if (gd->isVisible())
+ {
+ moduleList->append(ModuleContext::alloc(gd));
+ }
+ }
+ }
+ m_cache.modules.reset(moduleList);
+ }
+ return m_cache.modules.get();
+ }
+ TemplateVariant examples() const
+ {
+ if (!m_cache.examples)
+ {
+ TemplateList *exampleList = TemplateList::alloc();
+ if (m_groupDef->getExamples())
+ {
+ PageSDict::Iterator eli(*m_groupDef->getExamples());
+ PageDef *ex;
+ for (eli.toFirst();(ex=eli.current());++eli)
+ {
+ exampleList->append(PageContext::alloc(ex));
+ }
+ }
+ m_cache.examples.reset(exampleList);
+ }
+ return m_cache.examples.get();
+ }
+ TemplateVariant pages() const
+ {
+ if (!m_cache.pages)
+ {
+ TemplateList *pageList = TemplateList::alloc();
+ if (m_groupDef->getExamples())
+ {
+ PageSDict::Iterator eli(*m_groupDef->getPages());
+ PageDef *ex;
+ for (eli.toFirst();(ex=eli.current());++eli)
+ {
+ pageList->append(PageContext::alloc(ex));
+ }
+ }
+ m_cache.pages.reset(pageList);
+ }
+ return m_cache.pages.get();
+ }
+ TemplateVariant dirs() const
+ {
+ if (!m_cache.dirs)
+ {
+ TemplateList *dirList = TemplateList::alloc();
+ if (m_groupDef->getDirs())
+ {
+ QListIterator<DirDef> it(*m_groupDef->getDirs());
+ DirDef *dd;
+ for (it.toFirst();(dd=it.current());++it)
+ {
+ dirList->append(DirContext::alloc(dd));
+ }
+ }
+ m_cache.dirs.reset(dirList);
+ }
+ return m_cache.dirs.get();
+ }
+ TemplateVariant files() const
+ {
+ if (!m_cache.files)
+ {
+ TemplateList *fileList = TemplateList::alloc();
+ if (m_groupDef->getFiles())
+ {
+ QListIterator<FileDef> it(*m_groupDef->getFiles());
+ FileDef *fd;
+ for (it.toFirst();(fd=it.current());++it)
+ {
+ fileList->append(FileContext::alloc(fd));
+ }
+ }
+ m_cache.files.reset(fileList);
+ }
+ return m_cache.files.get();
+ }
+ TemplateVariant classes() const
+ {
+ if (!m_cache.classes)
+ {
+ TemplateList *classList = TemplateList::alloc();
+ if (m_groupDef->getClasses())
+ {
+ ClassSDict::Iterator sdi(*m_groupDef->getClasses());
+ ClassDef *cd;
+ for (sdi.toFirst();(cd=sdi.current());++sdi)
+ {
+ if (cd->visibleInParentsDeclList())
+ {
+ classList->append(ClassContext::alloc(cd));
+ }
+ }
+ }
+ m_cache.classes.reset(classList);
+ }
+ return m_cache.classes.get();
+ }
+ TemplateVariant namespaces() const
+ {
+ if (!m_cache.namespaces)
+ {
+ TemplateList *namespaceList = TemplateList::alloc();
+ if (m_groupDef->getNamespaces())
+ {
+ NamespaceSDict::Iterator sdi(*m_groupDef->getNamespaces());
+ NamespaceDef *nd;
+ for (sdi.toFirst();(nd=sdi.current());++sdi)
+ {
+ if (nd->isLinkable() && !nd->isConstantGroup())
+ {
+ namespaceList->append(NamespaceContext::alloc(nd));
+ }
+ }
+ }
+ m_cache.namespaces.reset(namespaceList);
+ }
+ return m_cache.namespaces.get();
+ }
+ TemplateVariant constantgroups() const
+ {
+ if (!m_cache.constantgroups)
+ {
+ TemplateList *namespaceList = TemplateList::alloc();
+ if (m_groupDef->getNamespaces())
+ {
+ NamespaceSDict::Iterator sdi(*m_groupDef->getNamespaces());
+ NamespaceDef *nd;
+ for (sdi.toFirst();(nd=sdi.current());++sdi)
+ {
+ if (nd->isLinkable() && nd->isConstantGroup())
+ {
+ namespaceList->append(NamespaceContext::alloc(nd));
+ }
+ }
+ }
+ m_cache.constantgroups.reset(namespaceList);
+ }
+ return m_cache.constantgroups.get();
+ }
+
+ TemplateVariant getMemberList(SharedPtr<MemberListInfoContext> &list,
+ MemberListType type,const char *title,bool detailed=FALSE) const
+ {
+ if (!list)
+ {
+ MemberList *ml = m_groupDef->getMemberList(type);
+ if (ml)
+ {
+ list.reset(MemberListInfoContext::alloc(m_groupDef,relPathAsString(),ml,title,detailed));
+ }
+ }
+ if (list)
+ {
+ return list.get();
+ }
+ else
+ {
+ return TemplateVariant(FALSE);
+ }
+ }
+ TemplateVariant macros() const
+ {
+ return getMemberList(m_cache.macros,MemberListType_decDefineMembers,theTranslator->trDefines());
+ }
+ TemplateVariant typedefs() const
+ {
+ return getMemberList(m_cache.typedefs,MemberListType_decTypedefMembers,theTranslator->trTypedefs());
+ }
+ TemplateVariant enums() const
+ {
+ return getMemberList(m_cache.enums,MemberListType_decEnumMembers,theTranslator->trEnumerations());
+ }
+ TemplateVariant enumValues() const
+ {
+ return getMemberList(m_cache.enums,MemberListType_decEnumValMembers,theTranslator->trEnumerationValues());
+ }
+ TemplateVariant functions() const
+ {
+ QCString title = theTranslator->trFunctions();
+ SrcLangExt lang = m_groupDef->getLanguage();
+ if (lang==SrcLangExt_Fortran) title=theTranslator->trSubprograms();
+ else if (lang==SrcLangExt_VHDL) title=VhdlDocGen::trFunctionAndProc();
+ return getMemberList(m_cache.functions,MemberListType_decFuncMembers,title);
+ }
+ TemplateVariant variables() const
+ {
+ return getMemberList(m_cache.variables,MemberListType_decVarMembers,theTranslator->trVariables());
+ }
+ TemplateVariant signals() const
+ {
+ return getMemberList(m_cache.signals,MemberListType_signals,theTranslator->trSignals());
+ }
+ TemplateVariant publicSlots() const
+ {
+ return getMemberList(m_cache.publicSlots,MemberListType_pubSlots,theTranslator->trPublicSlots());
+ }
+ TemplateVariant protectedSlots() const
+ {
+ return getMemberList(m_cache.protectedSlots,MemberListType_proSlots,theTranslator->trProtectedSlots());
+ }
+ TemplateVariant privateSlots() const
+ {
+ return getMemberList(m_cache.privateSlots,MemberListType_priSlots,theTranslator->trPrivateSlots());
+ }
+ TemplateVariant events() const
+ {
+ return getMemberList(m_cache.events,MemberListType_events,theTranslator->trEvents());
+ }
+ TemplateVariant properties() const
+ {
+ return getMemberList(m_cache.properties,MemberListType_properties,theTranslator->trProperties());
+ }
+ TemplateVariant friends() const
+ {
+ return getMemberList(m_cache.friends,MemberListType_friends,theTranslator->trFriends());
+ }
+ TemplateVariant memberGroups() const
+ {
+ if (!m_cache.memberGroups)
+ {
+ if (m_groupDef->getMemberGroupSDict())
+ {
+ m_cache.memberGroups.reset(MemberGroupListContext::alloc(m_groupDef,relPathAsString(),m_groupDef->getMemberGroupSDict(),m_groupDef->subGrouping()));
+ }
+ else
+ {
+ m_cache.memberGroups.reset(MemberGroupListContext::alloc());
+ }
+ }
+ return m_cache.memberGroups.get();
+ }
+ TemplateVariant detailedMacros() const
+ {
+ return getMemberList(m_cache.detailedMacros,MemberListType_docDefineMembers,theTranslator->trDefineDocumentation());
+ }
+ TemplateVariant detailedTypedefs() const
+ {
+ return getMemberList(m_cache.detailedTypedefs,MemberListType_docTypedefMembers,theTranslator->trTypedefDocumentation());
+ }
+ TemplateVariant detailedEnums() const
+ {
+ return getMemberList(m_cache.detailedEnums,MemberListType_docEnumMembers,theTranslator->trEnumerationTypeDocumentation());
+ }
+ TemplateVariant detailedEnumValues() const
+ {
+ return getMemberList(m_cache.detailedEnumValues,MemberListType_docEnumValMembers,theTranslator->trEnumerationValueDocumentation());
+ }
+ TemplateVariant detailedFunctions() const
+ {
+ QCString title = theTranslator->trFunctionDocumentation();
+ SrcLangExt lang = m_groupDef->getLanguage();
+ if (lang==SrcLangExt_Fortran) title=theTranslator->trSubprogramDocumentation();
+ return getMemberList(m_cache.detailedFunctions,MemberListType_docFuncMembers,title);
+ }
+ TemplateVariant detailedVariables() const
+ {
+ return getMemberList(m_cache.detailedVariables,MemberListType_docVarMembers,theTranslator->trVariableDocumentation());
+ }
+ TemplateVariant detailedSignals() const
+ {
+ return getMemberList(m_cache.detailedSignals,MemberListType_docSignalMembers,theTranslator->trSignals());
+ }
+ TemplateVariant detailedPublicSlots() const
+ {
+ return getMemberList(m_cache.detailedPublicSlots,MemberListType_docPubSlotMembers,theTranslator->trPublicSlots());
+ }
+ TemplateVariant detailedProtectedSlots() const
+ {
+ return getMemberList(m_cache.detailedProtectedSlots,MemberListType_docProSlotMembers,theTranslator->trProtectedSlots());
+ }
+ TemplateVariant detailedPrivateSlots() const
+ {
+ return getMemberList(m_cache.detailedPrivateSlots,MemberListType_docPriSlotMembers,theTranslator->trPrivateSlots());
+ }
+ TemplateVariant detailedEvents() const
+ {
+ return getMemberList(m_cache.detailedEvents,MemberListType_docEventMembers,theTranslator->trEventDocumentation(),TRUE);
+ }
+ TemplateVariant detailedProperties() const
+ {
+ return getMemberList(m_cache.detailedProperties,MemberListType_docPropMembers,theTranslator->trPropertyDocumentation(),TRUE);
+ }
+ TemplateVariant detailedFriends() const
+ {
+ return getMemberList(m_cache.detailedFriends,MemberListType_docFriendMembers,theTranslator->trFriends(),TRUE);
+ }
+ TemplateVariant inlineClasses() const
+ {
+ if (!m_cache.inlineClasses)
+ {
+ TemplateList *classList = TemplateList::alloc();
+ if (m_groupDef->getClasses())
+ {
+ ClassSDict::Iterator sdi(*m_groupDef->getClasses());
+ ClassDef *cd;
+ for (sdi.toFirst();(cd=sdi.current());++sdi)
+ {
+ if (cd->name().find('@')==-1 &&
+ cd->isLinkableInProject() &&
+ cd->isEmbeddedInOuterScope() &&
+ cd->partOfGroups()==0)
+ {
+ classList->append(ClassContext::alloc(cd));
+ }
+ }
+ }
+ m_cache.inlineClasses.reset(classList);
+ }
+ return m_cache.inlineClasses.get();
+ }
+ TemplateVariant compoundType() const
+ {
+ return "module"; //theTranslator->trGroup(FALSE,TRUE);
+ }
private:
GroupDef *m_groupDef;
+ struct Cachable
+ {
+ SharedPtr<TemplateList> modules;
+ SharedPtr<TemplateList> dirs;
+ SharedPtr<TemplateList> files;
+ SharedPtr<TemplateList> classes;
+ SharedPtr<TemplateList> namespaces;
+ SharedPtr<TemplateList> constantgroups;
+ SharedPtr<TemplateList> examples;
+ SharedPtr<TemplateList> pages;
+ SharedPtr<MemberListInfoContext> macros;
+ SharedPtr<MemberListInfoContext> typedefs;
+ SharedPtr<MemberListInfoContext> enums;
+ SharedPtr<MemberListInfoContext> enumValues;
+ SharedPtr<MemberListInfoContext> functions;
+ SharedPtr<MemberListInfoContext> variables;
+ SharedPtr<MemberListInfoContext> signals;
+ SharedPtr<MemberListInfoContext> publicSlots;
+ SharedPtr<MemberListInfoContext> protectedSlots;
+ SharedPtr<MemberListInfoContext> privateSlots;
+ SharedPtr<MemberListInfoContext> events;
+ SharedPtr<MemberListInfoContext> properties;
+ SharedPtr<MemberListInfoContext> friends;
+ SharedPtr<MemberGroupListContext> memberGroups;
+ SharedPtr<MemberListInfoContext> detailedMacros;
+ SharedPtr<MemberListInfoContext> detailedTypedefs;
+ SharedPtr<MemberListInfoContext> detailedEnums;
+ SharedPtr<MemberListInfoContext> detailedEnumValues;
+ SharedPtr<MemberListInfoContext> detailedFunctions;
+ SharedPtr<MemberListInfoContext> detailedVariables;
+ SharedPtr<MemberListInfoContext> detailedSignals;
+ SharedPtr<MemberListInfoContext> detailedPublicSlots;
+ SharedPtr<MemberListInfoContext> detailedProtectedSlots;
+ SharedPtr<MemberListInfoContext> detailedPrivateSlots;
+ SharedPtr<MemberListInfoContext> detailedEvents;
+ SharedPtr<MemberListInfoContext> detailedProperties;
+ SharedPtr<MemberListInfoContext> detailedFriends;
+ SharedPtr<TemplateList> inlineClasses;
+ ScopedPtr<DotGroupCollaboration> groupGraph;
+ };
+ mutable Cachable m_cache;
};
//%% }
@@ -4015,88 +4504,6 @@ TemplateVariant ModuleContext::get(const char *n) const
//------------------------------------------------------------------------
-//%% list NestedClassList[Class] : list of nested classes
-class NestedClassListContext::Private : public GenericNodeListContext
-{
-};
-
-NestedClassListContext::NestedClassListContext() : RefCountedContext("NestedClassListContext")
-{
- p = new Private;
-}
-
-NestedClassListContext::~NestedClassListContext()
-{
- delete p;
-}
-
-// TemplateListIntf
-int NestedClassListContext::count() const
-{
- return p->count();
-}
-
-TemplateVariant NestedClassListContext::at(int index) const
-{
- return p->at(index);
-}
-
-TemplateListIntf::ConstIterator *NestedClassListContext::createIterator() const
-{
- return p->createIterator();
-}
-
-void NestedClassListContext::append(ClassDef *cd)
-{
- if (cd)
- {
- p->append(ClassContext::alloc(cd));
- }
-}
-
-//------------------------------------------------------------------------
-
-//%% list NestedClassList[Class] : list of nested namespaces
-class NestedNamespaceListContext::Private : public GenericNodeListContext
-{
-};
-
-NestedNamespaceListContext::NestedNamespaceListContext() : RefCountedContext("NestedNamespaceListContext")
-{
- p = new Private;
-}
-
-NestedNamespaceListContext::~NestedNamespaceListContext()
-{
- delete p;
-}
-
-// TemplateListIntf
-int NestedNamespaceListContext::count() const
-{
- return p->count();
-}
-
-TemplateVariant NestedNamespaceListContext::at(int index) const
-{
- return p->at(index);
-}
-
-TemplateListIntf::ConstIterator *NestedNamespaceListContext::createIterator() const
-{
- return p->createIterator();
-}
-
-void NestedNamespaceListContext::append(NamespaceDef *cd)
-{
- if (cd)
- {
- p->append(NamespaceContext::alloc(cd));
- }
-}
-
-//------------------------------------------------------------------------
-
//%% list ClassList[Class] : list of classes
class ClassListContext::Private : public GenericNodeListContext
{
@@ -4152,6 +4559,107 @@ TemplateListIntf::ConstIterator *ClassListContext::createIterator() const
//------------------------------------------------------------------------
+//%% list ClassIndex[Class] : list of classes
+class ClassIndexContext::Private : public PropertyMapper
+{
+ public:
+ Private()
+ {
+ addProperty("list", this,&Private::list);
+ addProperty("fileName", this,&Private::fileName);
+ addProperty("relPath", this,&Private::relPath);
+ addProperty("highlight", this,&Private::highlight);
+ addProperty("subhighlight",this,&Private::subhighlight);
+ addProperty("title", this,&Private::title);
+ }
+ TemplateVariant list() const
+ {
+ if (!m_cache.classes)
+ {
+ TemplateList *classList = TemplateList::alloc();
+ if (Doxygen::classSDict)
+ {
+ ClassSDict::Iterator cli(*Doxygen::classSDict);
+ ClassDef *cd;
+ for (cli.toFirst() ; (cd=cli.current()) ; ++cli )
+ {
+ if (cd->getLanguage()==SrcLangExt_VHDL &&
+ ((VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::PACKAGECLASS ||
+ (VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::PACKBODYCLASS)
+ ) // no architecture
+ {
+ continue;
+ }
+ if (cd->isLinkableInProject() && cd->templateMaster()==0)
+ {
+ classList->append(ClassContext::alloc(cd));
+ }
+ }
+ }
+ m_cache.classes.reset(classList);
+ }
+ return m_cache.classes.get();
+ }
+ TemplateVariant fileName() const
+ {
+ return "classes";
+ }
+ TemplateVariant relPath() const
+ {
+ return "";
+ }
+ TemplateVariant highlight() const
+ {
+ return "classes";
+ }
+ TemplateVariant subhighlight() const
+ {
+ return "classindex";
+ }
+ TemplateVariant title() const
+ {
+ static bool fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN");
+ static bool vhdlOpt = Config_getBool("OPTIMIZE_OUTPUT_VHDL");
+ if (fortranOpt)
+ {
+ return theTranslator->trDataTypes();
+ }
+ else if (vhdlOpt)
+ {
+ return VhdlDocGen::trDesignUnits();
+ }
+ else
+ {
+ return theTranslator->trCompoundIndex();
+ }
+ }
+ private:
+ struct Cachable
+ {
+ SharedPtr<TemplateList> classes;
+ };
+ mutable Cachable m_cache;
+};
+
+ClassIndexContext::ClassIndexContext() : RefCountedContext("ClassIndexContext")
+{
+ p = new Private;
+ //p->addClasses(*Doxygen::hiddenClasses);
+}
+
+ClassIndexContext::~ClassIndexContext()
+{
+ delete p;
+}
+
+// TemplateStructIntf
+TemplateVariant ClassIndexContext::get(const char *n) const
+{
+ return p->get(n);
+}
+
+//------------------------------------------------------------------------
+
//%% struct ClassInheritanceNode: node in inheritance tree
//%% {
class ClassInheritanceNodeContext::Private : public PropertyMapper
@@ -4464,6 +4972,7 @@ class NestingNodeContext::Private : public PropertyMapper
addClasses();
addDirFiles();
addPages();
+ addModules();
}
TemplateVariant isLeafNode() const
{
@@ -4652,6 +5161,14 @@ class NestingNodeContext::Private : public PropertyMapper
m_children->addPages(*pd->getSubPages(),FALSE);
}
}
+ void addModules()
+ {
+ GroupDef *gd = m_def->definitionType()==Definition::TypeGroup ? (GroupDef*)m_def : 0;
+ if (gd && gd->getSubGroups())
+ {
+ m_children->addModules(*gd->getSubGroups());
+ }
+ }
private:
const NestingNodeContext *m_parent;
Definition *m_def;
@@ -4817,6 +5334,35 @@ class NestingContext::Private : public GenericNodeListContext
}
}
}
+ void addModules(const GroupSDict &groups)
+ {
+ GroupSDict::Iterator gli(groups);
+ GroupDef *gd;
+ for (gli.toFirst();(gd=gli.current());++gli)
+ {
+ static bool externalGroups = Config_getBool("EXTERNAL_GROUPS");
+ if (!gd->isASubGroup() && gd->isVisible() &&
+ (!gd->isReference() || externalGroups)
+ )
+ {
+ append(NestingNodeContext::alloc(m_parent,gd,m_index,m_level,FALSE));
+ m_index++;
+ }
+ }
+ }
+ void addModules(const GroupList &list)
+ {
+ GroupListIterator gli(list);
+ GroupDef *gd;
+ for (gli.toFirst();(gd=gli.current());++gli)
+ {
+ if (gd->isVisible())
+ {
+ append(NestingNodeContext::alloc(m_parent,gd,m_index,m_level,FALSE));
+ m_index++;
+ }
+ }
+ }
private:
const NestingNodeContext *m_parent;
int m_level;
@@ -4884,6 +5430,16 @@ void NestingContext::addPages(const PageSDict &pages,bool rootOnly)
p->addPages(pages,rootOnly);
}
+void NestingContext::addModules(const GroupSDict &modules)
+{
+ p->addModules(modules);
+}
+
+void NestingContext::addModules(const GroupList &modules)
+{
+ p->addModules(modules);
+}
+
//------------------------------------------------------------------------
static int computeMaxDepth(const TemplateListIntf *list)
@@ -5448,120 +6004,6 @@ TemplateVariant FileTreeContext::get(const char *name) const
//------------------------------------------------------------------------
-//%% struct PageNode: node is a directory hierarchy
-//%% {
-class PageNodeContext::Private : public PropertyMapper
-{
- public:
- Private(PageDef *pd) : m_pageDef(pd)
- {
- m_children.reset(PageNodeListContext::alloc());
- m_pageContext.reset(PageContext::alloc(pd));
- //%% bool is_leaf_node: true if this node does not have any children
- addProperty("is_leaf_node",this,&Private::isLeafNode);
- //%% PageList children: list of nested classes/namespaces
- addProperty("children",this,&Private::children);
- //%% Page page: page info
- addProperty("page",this,&Private::getPage);
- addPages();
- }
- TemplateVariant isLeafNode() const
- {
- return m_children->count()==0;
- }
- TemplateVariant children() const
- {
- return m_children.get();
- }
- TemplateVariant getPage() const
- {
- return m_pageContext.get();
- }
- void addPages()
- {
- if (m_pageDef->getSubPages())
- {
- m_children->addPages(*m_pageDef->getSubPages(),FALSE);
- }
- }
- private:
- PageDef *m_pageDef;
- SharedPtr<PageNodeListContext> m_children;
- SharedPtr<PageContext> m_pageContext;
-};
-//%% }
-
-PageNodeContext::PageNodeContext(PageDef *pd) : RefCountedContext("PageNodeContext")
-{
- p = new Private(pd);
-}
-
-PageNodeContext::~PageNodeContext()
-{
- delete p;
-}
-
-TemplateVariant PageNodeContext::get(const char *n) const
-{
- return p->get(n);
-}
-
-//------------------------------------------------------------------------
-
-//%% list PageList[PageNode]: list of directories and/or files
-class PageNodeListContext::Private : public GenericNodeListContext
-{
- public:
- void addPages(const PageSDict &pages,bool rootOnly)
- {
- //printf("** PageNodeListContext::Private(%d)\n",rootOnly);
- SDict<PageDef>::Iterator pli(pages);
- PageDef *pd;
- for (pli.toFirst();(pd=pli.current());++pli)
- {
- if (!rootOnly ||
- pd->getOuterScope()==0 ||
- pd->getOuterScope()->definitionType()!=Definition::TypePage)
- {
- append(PageNodeContext::alloc(pd));
- }
- }
- }
-};
-
-PageNodeListContext::PageNodeListContext() : RefCountedContext("PageNodeListContext")
-{
- p = new Private;
-}
-
-PageNodeListContext::~PageNodeListContext()
-{
- delete p;
-}
-
-// TemplateListIntf
-int PageNodeListContext::count() const
-{
- return p->count();
-}
-
-TemplateVariant PageNodeListContext::at(int index) const
-{
- return p->at(index);
-}
-
-TemplateListIntf::ConstIterator *PageNodeListContext::createIterator() const
-{
- return p->createIterator();
-}
-
-void PageNodeListContext::addPages(const PageSDict &pages,bool rootOnly)
-{
- p->addPages(pages,rootOnly);
-}
-
-//------------------------------------------------------------------------
-
//%% struct PageTree: tree of related pages
//%% {
class PageTreeContext::Private : public PropertyMapper
@@ -5659,65 +6101,28 @@ TemplateVariant PageTreeContext::get(const char *name) const
//------------------------------------------------------------------------
-//%% struct PageList: list of related pages
-//%% {
-class PageListContext::Private : public PropertyMapper
+//%% list PageList[Page]: list of pages
+class PageListContext::Private : public GenericNodeListContext
{
public:
- TemplateVariant items() const
- {
- return m_pageList.get();
- }
- TemplateVariant fileName() const
- {
- return "pages";
- }
- TemplateVariant relPath() const
- {
- return "";
- }
- TemplateVariant highlight() const
- {
- return "pages";
- }
- TemplateVariant subhighlight() const
- {
- return "";
- }
- TemplateVariant title() const
- {
- return theTranslator->trRelatedPages();
- }
- Private()
+ void addPages(const PageSDict &pages)
{
- m_pageList.reset(new GenericNodeListContext);
- // Add pages
- PageSDict::Iterator pdi(*Doxygen::pageSDict);
+ PageSDict::Iterator pdi(pages);
PageDef *pd=0;
for (pdi.toFirst();(pd=pdi.current());++pdi)
{
if (!pd->getGroupDef() && !pd->isReference())
{
- m_pageList->append(PageContext::alloc(pd));
+ append(PageContext::alloc(pd));
}
}
-
- //%% list[Page] items:
- addProperty("items",this,&Private::items);
- addProperty("fileName",this,&Private::fileName);
- addProperty("relPath",this,&Private::relPath);
- addProperty("highlight",this,&Private::highlight);
- addProperty("subhighlight",this,&Private::subhighlight);
- addProperty("title",this,&Private::title);
}
- private:
- SharedPtr<GenericNodeListContext> m_pageList;
};
-//%% }
-PageListContext::PageListContext() : RefCountedContext("PageListContext")
+PageListContext::PageListContext(const PageSDict *pages) : RefCountedContext("PageListContext")
{
p = new Private;
+ if (pages) p->addPages(*pages);
}
PageListContext::~PageListContext()
@@ -5725,70 +6130,20 @@ PageListContext::~PageListContext()
delete p;
}
-TemplateVariant PageListContext::get(const char *name) const
-{
- return p->get(name);
-}
-
-
-//------------------------------------------------------------------------
-
-//%% struct ModuleNode: node is a directory hierarchy
-//%% {
-class ModuleNodeContext::Private : public PropertyMapper
-{
- public:
- Private(GroupDef *gd) : m_groupDef(gd)
- {
- m_children.reset(ModuleListContext::alloc());
- m_moduleContext.reset(ModuleContext::alloc(gd));
- //%% bool is_leaf_node: true if this node does not have any children
- addProperty("is_leaf_node",this,&Private::isLeafNode);
- //%% ModuleList children: list of submodules
- addProperty("children",this,&Private::children);
- //%% Module module: module info
- addProperty("module",this,&Private::getModule);
- addModules();
- }
- TemplateVariant isLeafNode() const
- {
- return m_children->count()==0;
- }
- TemplateVariant children() const
- {
- return m_children.get();
- }
- TemplateVariant getModule() const
- {
- return m_moduleContext.get();
- }
- void addModules()
- {
- if (m_groupDef->getSubGroups())
- {
- m_children->addModules(*m_groupDef->getSubGroups());
- }
- }
- private:
- GroupDef *m_groupDef;
- SharedPtr<ModuleListContext> m_children;
- SharedPtr<ModuleContext> m_moduleContext;
-};
-//%% }
-
-ModuleNodeContext::ModuleNodeContext(GroupDef *gd) : RefCountedContext("ModuleNodeContext")
+// TemplateListIntf
+int PageListContext::count() const
{
- p = new Private(gd);
+ return p->count();
}
-ModuleNodeContext::~ModuleNodeContext()
+TemplateVariant PageListContext::at(int index) const
{
- delete p;
+ return p->at(index);
}
-TemplateVariant ModuleNodeContext::get(const char *n) const
+TemplateListIntf::ConstIterator *PageListContext::createIterator() const
{
- return p->get(n);
+ return p->createIterator();
}
//------------------------------------------------------------------------
@@ -5797,33 +6152,24 @@ TemplateVariant ModuleNodeContext::get(const char *n) const
class ModuleListContext::Private : public GenericNodeListContext
{
public:
- void addModules(const GroupSDict &modules)
+ void addModules()
{
- static bool externalGroups = Config_getBool("EXTERNAL_GROUPS");
- GroupSDict::Iterator gli(modules);
+ GroupSDict::Iterator gli(*Doxygen::groupSDict);
GroupDef *gd;
for (gli.toFirst();(gd=gli.current());++gli)
{
- if (!gd->isASubGroup() && gd->isVisible() && (!gd->isReference() || externalGroups))
+ if (!gd->isReference())
{
- append(ModuleNodeContext::alloc(gd));
+ append(ModuleContext::alloc(gd));
}
}
}
- void addModules(const GroupList &list)
- {
- QListIterator<GroupDef> gli(list);
- GroupDef *gd;
- for (gli.toFirst();(gd=gli.current());++gli)
- {
- append(ModuleNodeContext::alloc(gd));
- }
- }
};
ModuleListContext::ModuleListContext() : RefCountedContext("ModuleListContext")
{
p = new Private;
+ p->addModules();
}
ModuleListContext::~ModuleListContext()
@@ -5847,17 +6193,6 @@ TemplateListIntf::ConstIterator *ModuleListContext::createIterator() const
return p->createIterator();
}
-void ModuleListContext::addModules(const GroupSDict &modules)
-{
- p->addModules(modules);
-}
-
-void ModuleListContext::addModules(const GroupList &modules)
-{
- p->addModules(modules);
-}
-
-
//------------------------------------------------------------------------
//%% struct ModuleTree: tree of modules
@@ -5865,9 +6200,28 @@ void ModuleListContext::addModules(const GroupList &modules)
class ModuleTreeContext::Private : public PropertyMapper
{
public:
+ Private()
+ {
+ m_moduleTree.reset(NestingContext::alloc(0,0));
+ // Add modules
+ if (Doxygen::groupSDict)
+ {
+ m_moduleTree->addModules(*Doxygen::groupSDict);
+ }
+
+ //%% ModuleList tree:
+ addProperty("tree",this,&Private::tree);
+ addProperty("fileName",this,&Private::fileName);
+ addProperty("relPath",this,&Private::relPath);
+ addProperty("highlight",this,&Private::highlight);
+ addProperty("subhighlight",this,&Private::subhighlight);
+ addProperty("title",this,&Private::title);
+ addProperty("preferredDepth",this,&Private::preferredDepth);
+ addProperty("maxDepth",this,&Private::maxDepth);
+ }
TemplateVariant tree() const
{
- return m_moduleList.get();
+ return m_moduleTree.get();
}
TemplateVariant fileName() const
{
@@ -5889,25 +6243,35 @@ class ModuleTreeContext::Private : public PropertyMapper
{
return theTranslator->trModules();
}
- Private()
+ TemplateVariant maxDepth() const
{
- m_moduleList.reset(ModuleListContext::alloc());
- // Add modules
- if (Doxygen::groupSDict)
+ if (!m_cache.maxDepthComputed)
{
- m_moduleList->addModules(*Doxygen::groupSDict);
+ m_cache.maxDepth = computeMaxDepth(m_moduleTree.get());
+ m_cache.maxDepthComputed=TRUE;
}
-
- //%% ModuleList tree:
- addProperty("tree",this,&Private::tree);
- addProperty("fileName",this,&Private::fileName);
- addProperty("relPath",this,&Private::relPath);
- addProperty("highlight",this,&Private::highlight);
- addProperty("subhighlight",this,&Private::subhighlight);
- addProperty("title",this,&Private::title);
+ return m_cache.maxDepth;
+ }
+ TemplateVariant preferredDepth() const
+ {
+ if (!m_cache.preferredDepthComputed)
+ {
+ m_cache.preferredDepth = computePreferredDepth(m_moduleTree.get(),maxDepth().toInt());
+ m_cache.preferredDepthComputed=TRUE;
+ }
+ return m_cache.preferredDepth;
}
private:
- SharedPtr<ModuleListContext> m_moduleList;
+ SharedPtr<NestingContext> m_moduleTree;
+ struct Cachable
+ {
+ Cachable() : maxDepthComputed(FALSE), preferredDepthComputed(FALSE) {}
+ int maxDepth;
+ bool maxDepthComputed;
+ int preferredDepth;
+ bool preferredDepthComputed;
+ };
+ mutable Cachable m_cache;
};
//%% }
@@ -6027,12 +6391,7 @@ class ExampleListContext::Private : public PropertyMapper
}
Private()
{
- m_pageList.reset(PageNodeListContext::alloc());
- // Add pages
- if (Doxygen::exampleSDict)
- {
- m_pageList->addPages(*Doxygen::exampleSDict,FALSE);
- }
+ m_pageList.reset(PageListContext::alloc(Doxygen::exampleSDict));
//%% PageNodeList items:
addProperty("items",this,&Private::items);
@@ -6043,7 +6402,7 @@ class ExampleListContext::Private : public PropertyMapper
addProperty("title",this,&Private::title);
}
private:
- SharedPtr<PageNodeListContext> m_pageList;
+ SharedPtr<PageListContext> m_pageList;
};
//%% }
@@ -7137,86 +7496,91 @@ int RefCountedContext::s_totalCount;
void generateOutputViaTemplate()
{
{
- TemplateEngine e;
- TemplateContext *ctx = e.createContext();
- if (ctx)
- {
- SharedPtr<DoxygenContext> doxygen (DoxygenContext::alloc());
- SharedPtr<ConfigContext> config (ConfigContext::alloc());
- SharedPtr<TranslateContext> tr (TranslateContext::alloc());
- SharedPtr<ClassListContext> classList (ClassListContext::alloc());
- SharedPtr<ClassTreeContext> classTree (ClassTreeContext::alloc());
- SharedPtr<ClassHierarchyContext> classHierarchy (ClassHierarchyContext::alloc());
- SharedPtr<NamespaceListContext> namespaceList (NamespaceListContext::alloc());
- SharedPtr<NamespaceTreeContext> namespaceTree (NamespaceTreeContext::alloc());
- SharedPtr<DirListContext> dirList (DirListContext::alloc());
- SharedPtr<FileListContext> fileList (FileListContext::alloc());
- SharedPtr<FileTreeContext> fileTree (FileTreeContext::alloc());
- SharedPtr<PageTreeContext> pageTree (PageTreeContext::alloc());
- SharedPtr<PageListContext> pageList (PageListContext::alloc());
- SharedPtr<ModuleTreeContext> moduleTree (ModuleTreeContext::alloc());
- SharedPtr<ExampleListContext> exampleList (ExampleListContext::alloc());
- SharedPtr<PageContext> mainPage (PageContext::alloc(Doxygen::mainPage,TRUE));
-
- //%% Doxygen doxygen:
- ctx->set("doxygen",doxygen.get());
- //%% Translator tr:
- ctx->set("tr",tr.get());
- //%% Config config:
- ctx->set("config",config.get());
- //%% ClassList classList:
- ctx->set("classList",classList.get()); // not used for standard HTML
- //%% ClassTree classTree:
- ctx->set("classTree",classTree.get());
- // classIndex
- // globals
- // members
- //%% ClassHierarchy classHierarchy:
- ctx->set("classHierarchy",classHierarchy.get());
- //%% NamespaceList namespaceList:
- ctx->set("namespaceList",namespaceList.get());
- //%% NamespaceTree namespaceTree:
- ctx->set("namespaceTree",namespaceTree.get());
- //%% FileList fileList:
- ctx->set("fileList",fileList.get());
- //%% FileTree fileTree:
- ctx->set("fileTree",fileTree.get());
- //%% PageList pageList
- ctx->set("pageList",pageList.get());
- //%% PageTree pageTree
- ctx->set("pageTree",pageTree.get());
- //%% ModuleTree moduleTree
- ctx->set("moduleTree",moduleTree.get());
- //%% ExampleList exampleList
- ctx->set("exampleList",exampleList.get());
- //%% DirList dirList
- ctx->set("dirList",dirList.get());
- //%% Page mainPage
- ctx->set("mainPage",mainPage.get());
-
-
- // render HTML output
- Template *tpl = e.loadByName("htmllayout.tpl",1);
- if (tpl)
- {
- g_globals.outputFormat = ContextGlobals::Html;
- g_globals.dynSectionId = 0;
- g_globals.outputDir = Config_getString("HTML_OUTPUT");
- HtmlEscaper htmlEsc;
- ctx->setEscapeIntf(Config_getString("HTML_FILE_EXTENSION"),&htmlEsc);
- HtmlSpaceless spl;
- ctx->setSpacelessIntf(&spl);
- ctx->setOutputDirectory(g_globals.outputDir);
- FTextStream ts;
- tpl->render(ts,ctx);
- }
- e.unload(tpl);
-
- // TODO: render other outputs
- }
- delete ctx;
+ TemplateEngine e;
+ TemplateContext *ctx = e.createContext();
+ if (ctx)
+ {
+ SharedPtr<DoxygenContext> doxygen (DoxygenContext::alloc());
+ SharedPtr<ConfigContext> config (ConfigContext::alloc());
+ SharedPtr<TranslateContext> tr (TranslateContext::alloc());
+ SharedPtr<ClassListContext> classList (ClassListContext::alloc());
+ SharedPtr<ClassIndexContext> classIndex (ClassIndexContext::alloc());
+ SharedPtr<ClassTreeContext> classTree (ClassTreeContext::alloc());
+ SharedPtr<ClassHierarchyContext> classHierarchy (ClassHierarchyContext::alloc());
+ SharedPtr<NamespaceListContext> namespaceList (NamespaceListContext::alloc());
+ SharedPtr<NamespaceTreeContext> namespaceTree (NamespaceTreeContext::alloc());
+ SharedPtr<DirListContext> dirList (DirListContext::alloc());
+ SharedPtr<FileListContext> fileList (FileListContext::alloc());
+ SharedPtr<FileTreeContext> fileTree (FileTreeContext::alloc());
+ SharedPtr<PageTreeContext> pageTree (PageTreeContext::alloc());
+ SharedPtr<PageListContext> pageList (PageListContext::alloc(Doxygen::pageSDict));
+ SharedPtr<ExampleListContext> exampleList (ExampleListContext::alloc());
+ SharedPtr<ModuleTreeContext> moduleTree (ModuleTreeContext::alloc());
+ SharedPtr<ModuleListContext> moduleList (ModuleListContext::alloc());
+ SharedPtr<PageContext> mainPage (PageContext::alloc(Doxygen::mainPage,TRUE));
+
+ //%% Doxygen doxygen:
+ ctx->set("doxygen",doxygen.get());
+ //%% Translator tr:
+ ctx->set("tr",tr.get());
+ //%% Config config:
+ ctx->set("config",config.get());
+ //%% ClassList classList:
+ ctx->set("classList",classList.get()); // not used for standard HTML
+ //%% ClassTree classTree:
+ ctx->set("classTree",classTree.get());
+ //%% ClassIndex classIndex:
+ ctx->set("classIndex",classIndex.get());
+ // globals
+ // members
+ //%% ClassHierarchy classHierarchy:
+ ctx->set("classHierarchy",classHierarchy.get());
+ //%% NamespaceList namespaceList:
+ ctx->set("namespaceList",namespaceList.get());
+ //%% NamespaceTree namespaceTree:
+ ctx->set("namespaceTree",namespaceTree.get());
+ //%% FileList fileList:
+ ctx->set("fileList",fileList.get());
+ //%% FileTree fileTree:
+ ctx->set("fileTree",fileTree.get());
+ //%% PageList pageList
+ ctx->set("pageList",pageList.get());
+ //%% PageTree pageTree
+ ctx->set("pageTree",pageTree.get());
+ //%% ExampleList exampleList
+ ctx->set("exampleList",exampleList.get());
+ //%% ModuleTree moduleTree
+ ctx->set("moduleTree",moduleTree.get());
+ //%% ModuleList moduleList
+ ctx->set("moduleList",moduleList.get());
+ //%% DirList dirList
+ ctx->set("dirList",dirList.get());
+ //%% Page mainPage
+ ctx->set("mainPage",mainPage.get());
+
+ // render HTML output
+ Template *tpl = e.loadByName("htmllayout.tpl",1);
+ if (tpl)
+ {
+ g_globals.outputFormat = ContextGlobals::Html;
+ g_globals.dynSectionId = 0;
+ g_globals.outputDir = Config_getString("HTML_OUTPUT");
+ HtmlEscaper htmlEsc;
+ ctx->setEscapeIntf(Config_getString("HTML_FILE_EXTENSION"),&htmlEsc);
+ HtmlSpaceless spl;
+ ctx->setSpacelessIntf(&spl);
+ ctx->setOutputDirectory(g_globals.outputDir);
+ FTextStream ts;
+ tpl->render(ts,ctx);
+ e.unload(tpl);
+ }
+
+ // TODO: render other outputs
+
+ e.destroyContext(ctx);
+ }
}
-#if DEBUG_REF
+#if DEBUG_REF // should be 0, i.e. all objects are deleted
printf("==== total ref count %d\n",RefCountedContext::s_totalCount);
#endif
}
diff --git a/src/context.h b/src/context.h
index cc42527..7622e35 100644
--- a/src/context.h
+++ b/src/context.h
@@ -1,3 +1,18 @@
+/******************************************************************************
+ *
+ * Copyright (C) 1997-2014 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.
+ *
+ */
+
#ifndef CONTEXT_H
#define CONTEXT_H
@@ -364,10 +379,10 @@ class ModuleContext : public RefCountedContext, public TemplateStructIntf
//----------------------------------------------------
-class NestedClassListContext : public RefCountedContext, public TemplateListIntf
+class ClassListContext : public RefCountedContext, public TemplateListIntf
{
public:
- static NestedClassListContext *alloc() { return new NestedClassListContext; }
+ static ClassListContext *alloc() { return new ClassListContext; }
// TemplateListIntf
virtual int count() const;
@@ -376,55 +391,28 @@ class NestedClassListContext : public RefCountedContext, public TemplateListIntf
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
- void append(ClassDef *cd);
-
private:
- NestedClassListContext();
- ~NestedClassListContext();
+ ClassListContext();
+ ~ClassListContext();
class Private;
Private *p;
};
//----------------------------------------------------
-class NestedNamespaceListContext : public RefCountedContext, public TemplateListIntf
+class ClassIndexContext : public RefCountedContext, public TemplateStructIntf
{
public:
- static NestedNamespaceListContext *alloc() { return new NestedNamespaceListContext; }
+ static ClassIndexContext *alloc() { return new ClassIndexContext; }
- // TemplateListIntf
- virtual int count() const;
- virtual TemplateVariant at(int index) const;
- virtual TemplateListIntf::ConstIterator *createIterator() const;
+ // TemplateStructIntf methods
+ virtual TemplateVariant get(const char *name) const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
- void append(NamespaceDef *cd);
-
private:
- NestedNamespaceListContext();
- ~NestedNamespaceListContext();
- class Private;
- Private *p;
-};
-
-//----------------------------------------------------
-
-class ClassListContext : public RefCountedContext, public TemplateListIntf
-{
- public:
- static ClassListContext *alloc() { return new ClassListContext; }
-
- // TemplateListIntf
- virtual int count() const;
- virtual TemplateVariant at(int index) const;
- virtual TemplateListIntf::ConstIterator *createIterator() const;
- virtual int addRef() { return RefCountedContext::addRef(); }
- virtual int release() { return RefCountedContext::release(); }
-
- private:
- ClassListContext();
- ~ClassListContext();
+ ClassIndexContext();
+ ~ClassIndexContext();
class Private;
Private *p;
};
@@ -537,6 +525,8 @@ class NestingContext : public RefCountedContext, public TemplateListIntf
void addFiles(const FileNameList &);
void addFiles(const FileList &);
void addPages(const PageSDict &pages,bool rootOnly);
+ void addModules(const GroupSDict &modules);
+ void addModules(const GroupList &modules);
private:
NestingContext(const NestingNodeContext *parent,int level);
@@ -667,60 +657,22 @@ class FileTreeContext : public RefCountedContext, public TemplateStructIntf
//----------------------------------------------------
-class PageNodeContext : public RefCountedContext, public TemplateStructIntf
-{
- public:
- static PageNodeContext *alloc(PageDef *pd) { return new PageNodeContext(pd); }
-
- // TemplateStructIntf methods
- virtual TemplateVariant get(const char *name) const;
- virtual int addRef() { return RefCountedContext::addRef(); }
- virtual int release() { return RefCountedContext::release(); }
-
- private:
- PageNodeContext(PageDef *);
- ~PageNodeContext();
- class Private;
- Private *p;
-};
-
-//----------------------------------------------------
-
-class PageNodeListContext : public RefCountedContext, public TemplateListIntf
+class PageListContext : public RefCountedContext, public TemplateListIntf
{
public:
- static PageNodeListContext *alloc() { return new PageNodeListContext; }
+ static PageListContext *alloc(const PageSDict *pages) { return new PageListContext(pages); }
- // TemplateListIntf
+ // TemplateListIntf methods
virtual int count() const;
virtual TemplateVariant at(int index) const;
virtual TemplateListIntf::ConstIterator *createIterator() const;
virtual int addRef() { return RefCountedContext::addRef(); }
virtual int release() { return RefCountedContext::release(); }
- void addPages(const PageSDict &,bool rootOnly);
-
- private:
- PageNodeListContext();
- ~PageNodeListContext();
- class Private;
- Private *p;
-};
-
-//----------------------------------------------------
-
-class PageListContext : public RefCountedContext, public TemplateStructIntf
-{
- public:
- static PageListContext *alloc() { return new PageListContext; }
-
- // TemplateStructIntf methods
- virtual TemplateVariant get(const char *name) const;
- virtual int addRef() { return RefCountedContext::addRef(); }
- virtual int release() { return RefCountedContext::release(); }
+ void addPages(const PageSDict &pages);
private:
- PageListContext();
+ PageListContext(const PageSDict *pages);
~PageListContext();
class Private;
Private *p;
diff --git a/src/groupdef.cpp b/src/groupdef.cpp
index 85bfb8f..f1d1877 100644
--- a/src/groupdef.cpp
+++ b/src/groupdef.cpp
@@ -71,6 +71,7 @@ GroupDef::GroupDef(const char *df,int dl,const char *na,const char *t,
visited = 0;
groupScope = 0;
+ m_subGrouping=Config_getBool("SUBGROUPING");
}
GroupDef::~GroupDef()
@@ -1512,3 +1513,9 @@ void GroupDef::updateLanguage(const Definition *d)
}
}
+bool GroupDef::hasDetailedDescription() const
+{
+ static bool repeatBrief = Config_getBool("REPEAT_BRIEF");
+ return ((!briefDescription().isEmpty() && repeatBrief) ||
+ !documentation().isEmpty());
+}
diff --git a/src/groupdef.h b/src/groupdef.h
index 481bece..bc956da 100644
--- a/src/groupdef.h
+++ b/src/groupdef.h
@@ -79,6 +79,7 @@ class GroupDef : public Definition
void addListReferences();
void sortMemberLists();
+ bool subGrouping() const { return m_subGrouping; }
bool visited; // number of times accessed for output - KPW
@@ -101,6 +102,7 @@ class GroupDef : public Definition
PageSDict * getPages() const { return pageDict; }
DirList * getDirs() const { return dirList; }
PageSDict * getExamples() const { return exampleDict; }
+ bool hasDetailedDescription() const;
//MemberList* getMembers() const { return allMemberList; }
void sortSubGroups();
@@ -150,6 +152,7 @@ class GroupDef : public Definition
QList<MemberList> m_memberLists;
MemberGroupSDict *memberGroupSDict;
+ bool m_subGrouping;
};
diff --git a/src/template.cpp b/src/template.cpp
index 4b755e3..f9dd73e 100644
--- a/src/template.cpp
+++ b/src/template.cpp
@@ -1,3 +1,18 @@
+/******************************************************************************
+ *
+ * Copyright (C) 1997-2014 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.
+ *
+ */
+
#include "template.h"
#include <stdio.h>
@@ -347,6 +362,21 @@ TemplateVariant::Type TemplateVariant::type() const
return p->type;
}
+QCString TemplateVariant::typeAsString() const
+{
+ switch (p->type)
+ {
+ case None: return "none";
+ case Bool: return "bool";
+ case Integer: return "integer";
+ case String: return "string";
+ case Struct: return "struct";
+ case List: return "list";
+ case Function: return "function";
+ }
+ return "invalid";
+}
+
bool TemplateVariant::isValid() const
{
return p->type!=None;
@@ -963,7 +993,7 @@ class FilterListSort
//--------------------------------------------------------------------
-/** @brief The implementation of the "listsort" filter */
+/** @brief The implementation of the "paginate" filter */
class FilterPaginate
{
public:
@@ -1006,6 +1036,130 @@ class FilterPaginate
//--------------------------------------------------------------------
+/** @brief The implementation of the "alphaIndex" filter */
+class FilterAlphaIndex
+{
+ private:
+ struct ListElem
+ {
+ ListElem(uint k,const TemplateVariant &v) : key(k), value(v) {}
+ uint key;
+ TemplateVariant value;
+ };
+ class SortList : public QList<ListElem>
+ {
+ public:
+ SortList() { setAutoDelete(TRUE); }
+ private:
+ int compareValues(const ListElem *item1,const ListElem *item2) const
+ {
+ return item2->key-item1->key;
+ }
+ };
+ static QCString keyToLetter(uint startLetter)
+ {
+ return QString(QChar(startLetter)).utf8();
+ }
+ static QCString keyToLabel(uint startLetter)
+ {
+ char s[10];
+ if (startLetter>0x20 && startLetter<=0x7f) // printable ASCII character
+ {
+ s[0]=(char)startLetter;
+ s[1]=0;
+ }
+ else
+ {
+ const char hex[]="0123456789abcdef";
+ int i=0;
+ s[i++]='0';
+ s[i++]='x';
+ if (startLetter>(1<<24)) // 4 byte character
+ {
+ s[i++]=hex[(startLetter>>28)&0xf];
+ s[i++]=hex[(startLetter>>24)&0xf];
+ }
+ if (startLetter>(1<<16)) // 3 byte character
+ {
+ s[i++]=hex[(startLetter>>20)&0xf];
+ s[i++]=hex[(startLetter>>16)&0xf];
+ }
+ if (startLetter>(1<<8)) // 2 byte character
+ {
+ s[i++]=hex[(startLetter>>12)&0xf];
+ s[i++]=hex[(startLetter>>8)&0xf];
+ }
+ // one byte character
+ s[i++]=hex[(startLetter>>4)&0xf];
+ s[i++]=hex[(startLetter>>0)&0xf];
+ s[i++]=0;
+ }
+ return s;
+ }
+ static uint determineSortKey(TemplateStructIntf *s,const QCString &attribName)
+ {
+ TemplateVariant v = s->get(attribName);
+ int index = getPrefixIndex(v.toString());
+ return getUtf8CodeToUpper(v.toString(),index);
+ }
+
+ public:
+ static TemplateVariant apply(const TemplateVariant &v,const TemplateVariant &args)
+ {
+ if (v.type()==TemplateVariant::List && args.type()==TemplateVariant::String)
+ {
+ //printf("FilterListSort::apply: v=%s args=%s\n",v.toString().data(),args.toString().data());
+ TemplateListIntf::ConstIterator *it = v.toList()->createIterator();
+
+ TemplateVariant item;
+ TemplateList *result = TemplateList::alloc();
+
+ // create list of items based on v using the data in args as a sort key
+ SortList sortList;
+ for (it->toFirst();(it->current(item));it->toNext())
+ {
+ TemplateStructIntf *s = item.toStruct();
+ if (s)
+ {
+ uint sortKey = determineSortKey(s,args.toString());
+ sortList.append(new ListElem(sortKey,item));
+ //printf("sortKey=%s\n",sortKey.data());
+ }
+ }
+ delete it;
+
+ // sort the list
+ sortList.sort();
+
+ // create an index from the sorted list
+ uint letter=0;
+ QListIterator<ListElem> sit(sortList);
+ ListElem *elem;
+ TemplateStruct *indexNode = 0;
+ TemplateList *indexList = 0;
+ for (sit.toFirst();(elem=sit.current());++sit)
+ {
+ if (letter!=elem->key || indexNode==0)
+ {
+ // create new indexNode
+ indexNode = TemplateStruct::alloc();
+ indexList = TemplateList::alloc();
+ indexNode->set("letter", keyToLetter(elem->key));
+ indexNode->set("label", keyToLabel(elem->key));
+ indexNode->set("classes",indexList);
+ result->append(indexNode);
+ letter=elem->key;
+ }
+ indexList->append(elem->value);
+ }
+ return result;
+ }
+ return v;
+ }
+};
+
+//--------------------------------------------------------------------
+
/** @brief The implementation of the "default" filter */
class FilterStripPath
{
@@ -1132,6 +1286,7 @@ static TemplateFilterFactory::AutoRegister<FilterPrepend> fPrepend("prepend"
static TemplateFilterFactory::AutoRegister<FilterListSort> fListSort("listsort");
static TemplateFilterFactory::AutoRegister<FilterPaginate> fPaginate("paginate");
static TemplateFilterFactory::AutoRegister<FilterStripPath> fStripPath("stripPath");
+static TemplateFilterFactory::AutoRegister<FilterAlphaIndex> fAlphaIndex("alphaIndex");
static TemplateFilterFactory::AutoRegister<FilterDivisibleBy> fDivisibleBy("divisibleby");
//--------------------------------------------------------------------
@@ -2898,7 +3053,7 @@ class TemplateNodeFor : public TemplateNodeCreator<TemplateNodeFor>
}
else // simple type...
{
- ci->warn(m_templateName,m_line,"for requires a variable of list type!");
+ ci->warn(m_templateName,m_line,"for requires a variable of list type, got type '%s'!",v.typeAsString().data());
}
}
}
@@ -4499,6 +4654,11 @@ TemplateContext *TemplateEngine::createContext() const
return new TemplateContextImpl(this);
}
+void TemplateEngine::destroyContext(TemplateContext *ctx)
+{
+ delete ctx;
+}
+
Template *TemplateEngine::loadByName(const QCString &fileName,int line)
{
return p->loadByName(fileName,line);
diff --git a/src/template.h b/src/template.h
index cb4a96f..7994216 100644
--- a/src/template.h
+++ b/src/template.h
@@ -1,3 +1,18 @@
+/******************************************************************************
+ *
+ * Copyright (C) 1997-2014 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.
+ *
+ */
+
#ifndef TEMPLATE_H
#define TEMPLATE_H
@@ -126,6 +141,9 @@ class TemplateVariant
/** Returns the type of the value stored in the variant */
Type type() const;
+ /** Return a string representation of the type of the value stored in the variant */
+ QCString typeAsString() const;
+
/** Returns TRUE if the variant holds a valid value, or FALSE otherwise */
bool isValid() const;
@@ -485,6 +503,11 @@ class TemplateEngine
*/
TemplateContext *createContext() const;
+ /** Destroys a context created via createContext().
+ * @param[in] ctx The context.
+ */
+ void destroyContext(TemplateContext *ctx);
+
/** Creates a new template whole contents are in a file.
* @param[in] fileName The name of the file containing the
* template data
diff --git a/src/translator_en.h b/src/translator_en.h
index ca0a151..5937ed3 100644
--- a/src/translator_en.h
+++ b/src/translator_en.h
@@ -1224,7 +1224,7 @@ class TranslatorEnglish : public Translator
*/
virtual QCString trGroup(bool first_capital, bool singular)
{
- QCString result((first_capital ? "Group" : "group"));
+ QCString result((first_capital ? "Module" : "module"));
if (!singular) result+="s";
return result;
}
generated by cgit v0.12 at 2024-11-01 07:53:47 (GMT)