From e0c3517ff9369387e00dd596b094a4729cfe789c Mon Sep 17 00:00:00 2001 From: Dimitri van Heesch Date: Mon, 2 Jun 2014 21:59:09 +0200 Subject: Addition of module data to context and alphaIndex filter --- src/context.cpp | 1546 +++++++++++++++++++++++++++++++-------------------- src/context.h | 112 ++-- src/groupdef.cpp | 7 + src/groupdef.h | 3 + src/template.cpp | 164 +++++- src/template.h | 23 + src/translator_en.h | 2 +- 7 files changed, 1183 insertions(+), 674 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 { 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 { if (cd->visibleInParentsDeclList()) { - classList->append(cd); + classList->append(ClassContext::alloc(cd)); } } } @@ -1975,7 +2002,7 @@ class ClassContext::Private : public DefinitionContext SharedPtr inheritedByList; ScopedPtr classGraph; ScopedPtr collaborationGraph; - SharedPtr classes; + SharedPtr classes; SharedPtr publicTypes; SharedPtr publicMethods; SharedPtr publicStaticMethods; @@ -2100,7 +2127,7 @@ class NamespaceContext::Private : public DefinitionContextgetClassSDict()) { ClassSDict::Iterator sdi(*m_namespaceDef->getClassSDict()); @@ -2109,7 +2136,7 @@ class NamespaceContext::Private : public DefinitionContextvisibleInParentsDeclList()) { - classList->append(cd); + classList->append(ClassContext::alloc(cd)); } } } @@ -2121,7 +2148,7 @@ class NamespaceContext::Private : public DefinitionContextgetNamespaceSDict()) { NamespaceSDict::Iterator sdi(*m_namespaceDef->getNamespaceSDict()); @@ -2130,7 +2157,7 @@ class NamespaceContext::Private : public DefinitionContextisLinkable() && !nd->isConstantGroup()) { - namespaceList->append(nd); + namespaceList->append(NamespaceContext::alloc(nd)); } } } @@ -2142,7 +2169,7 @@ class NamespaceContext::Private : public DefinitionContextgetNamespaceSDict()) { NamespaceSDict::Iterator sdi(*m_namespaceDef->getNamespaceSDict()); @@ -2151,7 +2178,7 @@ class NamespaceContext::Private : public DefinitionContextisLinkable() && nd->isConstantGroup()) { - namespaceList->append(nd); + namespaceList->append(NamespaceContext::alloc(nd)); } } } @@ -2189,9 +2216,11 @@ class NamespaceContext::Private : public DefinitionContexttrFunctions()); + 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 DefinitionContexttrFunctionDocumentation()); + 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 DefinitionContextgetClassSDict()) { ClassSDict::Iterator sdi(*m_namespaceDef->getClassSDict()); @@ -2245,7 +2276,7 @@ class NamespaceContext::Private : public DefinitionContextisEmbeddedInOuterScope() && cd->partOfGroups()==0) { - classList->append(cd); + classList->append(ClassContext::alloc(cd)); } } } @@ -2257,9 +2288,9 @@ class NamespaceContext::Private : public DefinitionContext classes; - SharedPtr namespaces; - SharedPtr constantgroups; + SharedPtr classes; + SharedPtr namespaces; + SharedPtr constantgroups; SharedPtr typedefs; SharedPtr enums; SharedPtr functions; @@ -2269,7 +2300,7 @@ class NamespaceContext::Private : public DefinitionContext detailedEnums; SharedPtr detailedFunctions; SharedPtr detailedVariables; - SharedPtr inlineClasses; + SharedPtr inlineClasses; }; mutable Cachable m_cache; }; @@ -2455,7 +2486,7 @@ class FileContext::Private : public DefinitionContext { 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 { if (cd->visibleInParentsDeclList()) { - classList->append(cd); + classList->append(ClassContext::alloc(cd)); } } } @@ -2476,7 +2507,7 @@ class FileContext::Private : public DefinitionContext { 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 { if (nd->isLinkable() && !nd->isConstantGroup()) { - namespaceList->append(nd); + namespaceList->append(NamespaceContext::alloc(nd)); } } } @@ -2497,7 +2528,7 @@ class FileContext::Private : public DefinitionContext { 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 { if (nd->isLinkable() && nd->isConstantGroup()) { - namespaceList->append(nd); + namespaceList->append(NamespaceContext::alloc(nd)); } } } @@ -2548,9 +2579,11 @@ class FileContext::Private : public DefinitionContext } 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 } 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 { 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 cd->isEmbeddedInOuterScope() && cd->partOfGroups()==0) { - classList->append(cd); + classList->append(ClassContext::alloc(cd)); } } } @@ -2629,9 +2664,9 @@ class FileContext::Private : public DefinitionContext ScopedPtr includeGraph; ScopedPtr includedByGraph; ScopedPtr sources; - SharedPtr classes; - SharedPtr namespaces; - SharedPtr constantgroups; + SharedPtr classes; + SharedPtr namespaces; + SharedPtr constantgroups; SharedPtr macros; SharedPtr typedefs; SharedPtr enums; @@ -2643,7 +2678,7 @@ class FileContext::Private : public DefinitionContext SharedPtr detailedEnums; SharedPtr detailedFunctions; SharedPtr detailedVariables; - SharedPtr inlineClasses; + SharedPtr inlineClasses; }; mutable Cachable m_cache; }; @@ -3977,9 +4012,48 @@ class ModuleContext::Private : public DefinitionContext public: Private(GroupDef *gd) : DefinitionContext(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,231 +4067,665 @@ class ModuleContext::Private : public DefinitionContext { return TemplateVariant(""); } - private: - GroupDef *m_groupDef; -}; -//%% } - -ModuleContext::ModuleContext(GroupDef *gd) : RefCountedContext("ModuleContext") -{ - p = new Private(gd); -} - -ModuleContext::~ModuleContext() -{ - delete p; -} - -TemplateVariant ModuleContext::get(const char *n) const -{ - return p->get(n); -} - -//------------------------------------------------------------------------ - -//%% 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 -{ - public: - void addClasses(const ClassSDict &classSDict) + DotGroupCollaboration *getGroupGraph() const { - ClassSDict::Iterator cli(classSDict); - ClassDef *cd; - for (cli.toFirst() ; (cd=cli.current()) ; ++cli ) + if (!m_cache.groupGraph) { - 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) - { - append(ClassContext::alloc(cd)); - } + m_cache.groupGraph.reset(new DotGroupCollaboration(m_groupDef)); } + return m_cache.groupGraph.get(); } -}; - -ClassListContext::ClassListContext() : RefCountedContext("ClassListContext") -{ - p = new Private; - p->addClasses(*Doxygen::classSDict); - p->addClasses(*Doxygen::hiddenClasses); -} - -ClassListContext::~ClassListContext() -{ - delete p; -} - -// TemplateListIntf -int ClassListContext::count() const -{ - return p->count(); -} - -TemplateVariant ClassListContext::at(int index) const -{ - return p->at(index); -} - -TemplateListIntf::ConstIterator *ClassListContext::createIterator() const -{ - return p->createIterator(); -} - -//------------------------------------------------------------------------ - -//%% struct ClassInheritanceNode: node in inheritance tree -//%% { -class ClassInheritanceNodeContext::Private : public PropertyMapper -{ - public: - Private(ClassDef *cd) : m_classDef(cd) + TemplateVariant hasGroupGraph() const { - //%% bool is_leaf_node: true if this node does not have any children - addProperty("is_leaf_node",this,&Private::isLeafNode); - //%% ClassInheritance children: list of nested classes/namespaces - addProperty("children",this,&Private::children); - //%% Class class: class info - addProperty("class",this,&Private::getClass); + 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; } - void addChildren(const BaseClassList *bcl,bool hideSuper) + TemplateVariant groupGraph() const { - if (bcl==0) return; - BaseClassListIterator bcli(*bcl); - BaseClassDef *bcd; - for (bcli.toFirst() ; (bcd=bcli.current()) ; ++bcli) + QGString result; + static bool haveDot = Config_getBool("HAVE_DOT"); + static bool groupGraphs = Config_getBool("GROUP_GRAPHS"); + if (haveDot && groupGraphs) { - ClassDef *cd=bcd->classDef; - if (cd->getLanguage()==SrcLangExt_VHDL && (VhdlDocGen::VhdlClasses)cd->protection()!=VhdlDocGen::ENTITYCLASS) - { - continue; - } - - bool b; - if (cd->getLanguage()==SrcLangExt_VHDL) - { - b=hasVisibleRoot(cd->subClasses()); - } - else - { - b=hasVisibleRoot(cd->baseClasses()); - } - - if (cd->isVisibleInHierarchy() && b) // hasVisibleRoot(cd->baseClasses())) + 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()) { - bool hasChildren = !cd->visited && !hideSuper && classHasVisibleChildren(cd); - ClassInheritanceNodeContext *tnc = new ClassInheritanceNodeContext(cd); - m_children.append(tnc); - if (hasChildren) + GroupListIterator gli(*m_groupDef->getSubGroups()); + GroupDef *gd; + for (gli.toFirst();(gd=gli.current());++gli) { - //printf("Class %s at %p visited=%d\n",cd->name().data(),cd,cd->visited); - bool wasVisited=cd->visited; - cd->visited=TRUE; - if (cd->getLanguage()==SrcLangExt_VHDL) - { - tnc->addChildren(cd->baseClasses(),wasVisited); - } - else + if (gd->isVisible()) { - tnc->addChildren(cd->subClasses(),wasVisited); + moduleList->append(ModuleContext::alloc(gd)); } } } + m_cache.modules.reset(moduleList); } + return m_cache.modules.get(); } - TemplateVariant isLeafNode() const + TemplateVariant examples() const { - return m_children.isEmpty(); + 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 children() const + TemplateVariant pages() const { - return TemplateVariant(&m_children); + 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 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 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 &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 modules; + SharedPtr dirs; + SharedPtr files; + SharedPtr classes; + SharedPtr namespaces; + SharedPtr constantgroups; + SharedPtr examples; + SharedPtr pages; + SharedPtr macros; + SharedPtr typedefs; + SharedPtr enums; + SharedPtr enumValues; + SharedPtr functions; + SharedPtr variables; + SharedPtr signals; + SharedPtr publicSlots; + SharedPtr protectedSlots; + SharedPtr privateSlots; + SharedPtr events; + SharedPtr properties; + SharedPtr friends; + SharedPtr memberGroups; + SharedPtr detailedMacros; + SharedPtr detailedTypedefs; + SharedPtr detailedEnums; + SharedPtr detailedEnumValues; + SharedPtr detailedFunctions; + SharedPtr detailedVariables; + SharedPtr detailedSignals; + SharedPtr detailedPublicSlots; + SharedPtr detailedProtectedSlots; + SharedPtr detailedPrivateSlots; + SharedPtr detailedEvents; + SharedPtr detailedProperties; + SharedPtr detailedFriends; + SharedPtr inlineClasses; + ScopedPtr groupGraph; + }; + mutable Cachable m_cache; +}; +//%% } + +ModuleContext::ModuleContext(GroupDef *gd) : RefCountedContext("ModuleContext") +{ + p = new Private(gd); +} + +ModuleContext::~ModuleContext() +{ + delete p; +} + +TemplateVariant ModuleContext::get(const char *n) const +{ + return p->get(n); +} + +//------------------------------------------------------------------------ + +//%% list ClassList[Class] : list of classes +class ClassListContext::Private : public GenericNodeListContext +{ + public: + void addClasses(const ClassSDict &classSDict) + { + ClassSDict::Iterator cli(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) + { + append(ClassContext::alloc(cd)); + } + } + } +}; + +ClassListContext::ClassListContext() : RefCountedContext("ClassListContext") +{ + p = new Private; + p->addClasses(*Doxygen::classSDict); + p->addClasses(*Doxygen::hiddenClasses); +} + +ClassListContext::~ClassListContext() +{ + delete p; +} + +// TemplateListIntf +int ClassListContext::count() const +{ + return p->count(); +} + +TemplateVariant ClassListContext::at(int index) const +{ + return p->at(index); +} + +TemplateListIntf::ConstIterator *ClassListContext::createIterator() const +{ + return p->createIterator(); +} + +//------------------------------------------------------------------------ + +//%% 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 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 +{ + public: + Private(ClassDef *cd) : m_classDef(cd) + { + //%% bool is_leaf_node: true if this node does not have any children + addProperty("is_leaf_node",this,&Private::isLeafNode); + //%% ClassInheritance children: list of nested classes/namespaces + addProperty("children",this,&Private::children); + //%% Class class: class info + addProperty("class",this,&Private::getClass); + } + void addChildren(const BaseClassList *bcl,bool hideSuper) + { + if (bcl==0) return; + BaseClassListIterator bcli(*bcl); + BaseClassDef *bcd; + for (bcli.toFirst() ; (bcd=bcli.current()) ; ++bcli) + { + ClassDef *cd=bcd->classDef; + if (cd->getLanguage()==SrcLangExt_VHDL && (VhdlDocGen::VhdlClasses)cd->protection()!=VhdlDocGen::ENTITYCLASS) + { + continue; + } + + bool b; + if (cd->getLanguage()==SrcLangExt_VHDL) + { + b=hasVisibleRoot(cd->subClasses()); + } + else + { + b=hasVisibleRoot(cd->baseClasses()); + } + + if (cd->isVisibleInHierarchy() && b) // hasVisibleRoot(cd->baseClasses())) + { + bool hasChildren = !cd->visited && !hideSuper && classHasVisibleChildren(cd); + ClassInheritanceNodeContext *tnc = new ClassInheritanceNodeContext(cd); + m_children.append(tnc); + if (hasChildren) + { + //printf("Class %s at %p visited=%d\n",cd->name().data(),cd,cd->visited); + bool wasVisited=cd->visited; + cd->visited=TRUE; + if (cd->getLanguage()==SrcLangExt_VHDL) + { + tnc->addChildren(cd->baseClasses(),wasVisited); + } + else + { + tnc->addChildren(cd->subClasses(),wasVisited); + } + } + } + } + } + TemplateVariant isLeafNode() const + { + return m_children.isEmpty(); + } + TemplateVariant children() const + { + return TemplateVariant(&m_children); } TemplateVariant getClass() const { @@ -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; @@ -4808,11 +5325,40 @@ class NestingContext::Private : public GenericNodeListContext PageDef *pd; for (pli.toFirst();(pd=pli.current());++pli) { - if (!rootOnly || - pd->getOuterScope()==0 || - pd->getOuterScope()->definitionType()!=Definition::TypePage) + if (!rootOnly || + pd->getOuterScope()==0 || + pd->getOuterScope()->definitionType()!=Definition::TypePage) + { + append(NestingNodeContext::alloc(m_parent,pd,m_index,m_level,FALSE)); + m_index++; + } + } + } + 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,pd,m_index,m_level,FALSE)); + append(NestingNodeContext::alloc(m_parent,gd,m_index,m_level,FALSE)); m_index++; } } @@ -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 m_children; - SharedPtr 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::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 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 m_children; - SharedPtr 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 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 m_moduleList; + SharedPtr 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 m_pageList; + SharedPtr m_pageList; }; //%% } @@ -7137,86 +7496,91 @@ int RefCountedContext::s_totalCount; void generateOutputViaTemplate() { { - TemplateEngine e; - TemplateContext *ctx = e.createContext(); - if (ctx) - { - SharedPtr doxygen (DoxygenContext::alloc()); - SharedPtr config (ConfigContext::alloc()); - SharedPtr tr (TranslateContext::alloc()); - SharedPtr classList (ClassListContext::alloc()); - SharedPtr classTree (ClassTreeContext::alloc()); - SharedPtr classHierarchy (ClassHierarchyContext::alloc()); - SharedPtr namespaceList (NamespaceListContext::alloc()); - SharedPtr namespaceTree (NamespaceTreeContext::alloc()); - SharedPtr dirList (DirListContext::alloc()); - SharedPtr fileList (FileListContext::alloc()); - SharedPtr fileTree (FileTreeContext::alloc()); - SharedPtr pageTree (PageTreeContext::alloc()); - SharedPtr pageList (PageListContext::alloc()); - SharedPtr moduleTree (ModuleTreeContext::alloc()); - SharedPtr exampleList (ExampleListContext::alloc()); - SharedPtr 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 doxygen (DoxygenContext::alloc()); + SharedPtr config (ConfigContext::alloc()); + SharedPtr tr (TranslateContext::alloc()); + SharedPtr classList (ClassListContext::alloc()); + SharedPtr classIndex (ClassIndexContext::alloc()); + SharedPtr classTree (ClassTreeContext::alloc()); + SharedPtr classHierarchy (ClassHierarchyContext::alloc()); + SharedPtr namespaceList (NamespaceListContext::alloc()); + SharedPtr namespaceTree (NamespaceTreeContext::alloc()); + SharedPtr dirList (DirListContext::alloc()); + SharedPtr fileList (FileListContext::alloc()); + SharedPtr fileTree (FileTreeContext::alloc()); + SharedPtr pageTree (PageTreeContext::alloc()); + SharedPtr pageList (PageListContext::alloc(Doxygen::pageSDict)); + SharedPtr exampleList (ExampleListContext::alloc()); + SharedPtr moduleTree (ModuleTreeContext::alloc()); + SharedPtr moduleList (ModuleListContext::alloc()); + SharedPtr 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 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 @@ -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 + { + 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 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 fPrepend("prepend" static TemplateFilterFactory::AutoRegister fListSort("listsort"); static TemplateFilterFactory::AutoRegister fPaginate("paginate"); static TemplateFilterFactory::AutoRegister fStripPath("stripPath"); +static TemplateFilterFactory::AutoRegister fAlphaIndex("alphaIndex"); static TemplateFilterFactory::AutoRegister fDivisibleBy("divisibleby"); //-------------------------------------------------------------------- @@ -2898,7 +3053,7 @@ class TemplateNodeFor : public TemplateNodeCreator } 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; } -- cgit v0.12