summaryrefslogtreecommitdiffstats
path: root/src/context.cpp
diff options
context:
space:
mode:
authorDimitri van Heesch <dimitri@stack.nl>2014-12-14 15:39:29 (GMT)
committerDimitri van Heesch <dimitri@stack.nl>2014-12-25 12:43:31 (GMT)
commitfe818bf8e3a154788a4a180068cfdfbbadd66ff6 (patch)
treec08545cd15e627b36eef1e0d0a7eb4fa0bb76437 /src/context.cpp
parent3ebc431569aa6566389f3f3fc00aae7b8a90e58b (diff)
downloadDoxygen-fe818bf8e3a154788a4a180068cfdfbbadd66ff6.zip
Doxygen-fe818bf8e3a154788a4a180068cfdfbbadd66ff6.tar.gz
Doxygen-fe818bf8e3a154788a4a180068cfdfbbadd66ff6.tar.bz2
Added graphical hierarchy support to template engine
Diffstat (limited to 'src/context.cpp')
-rw-r--r--src/context.cpp573
1 files changed, 302 insertions, 271 deletions
diff --git a/src/context.cpp b/src/context.cpp
index 06bc14c..ae5d5bc 100644
--- a/src/context.cpp
+++ b/src/context.cpp
@@ -666,6 +666,18 @@ class TranslateContext::Private : public PropertyMapper
static bool extractAll = Config_getBool("EXTRACT_ALL");
return theTranslator->trNamespaceMemberDescription(extractAll);
}
+ TemplateVariant classHierarchyDescription() const
+ {
+ return theTranslator->trClassHierarchyDescription();
+ }
+ TemplateVariant gotoGraphicalHierarchy() const
+ {
+ return theTranslator->trGotoGraphicalHierarchy();
+ }
+ TemplateVariant gotoTextualHierarchy() const
+ {
+ return theTranslator->trGotoTextualHierarchy();
+ }
TemplateVariant classMembersDescription() const
{
static bool extractAll = Config_getBool("EXTRACT_ALL");
@@ -1012,6 +1024,12 @@ class TranslateContext::Private : public PropertyMapper
addProperty("macros", this,&Private::macros);
//%% string namespaceMembersDescription
addProperty("namespaceMembersDescription",this,&Private::namespaceMembersDescription);
+ //%% string classHierarchyDescription
+ addProperty("classHierarchyDescription",this,&Private::classHierarchyDescription);
+ //%% string gotoGraphicalHierarchy
+ addProperty("gotoGraphicalHierarchy",this,&Private::gotoGraphicalHierarchy);
+ //%% string gotoTextualHierarchy
+ addProperty("gotoTextualHierarchy",this,&Private::gotoTextualHierarchy);
m_javaOpt = Config_getBool("OPTIMIZE_OUTPUT_JAVA");
m_fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN");
@@ -4822,194 +4840,74 @@ TemplateVariant ClassIndexContext::get(const char *n) const
//------------------------------------------------------------------------
-//%% struct ClassInheritanceNode: node in inheritance tree
-//%% {
-class ClassInheritanceNodeContext::Private : public PropertyMapper
+static int computeMaxDepth(const TemplateListIntf *list)
{
- public:
- Private(ClassDef *cd) : m_classDef(cd)
+ int maxDepth=0;
+ if (list)
+ {
+ TemplateListIntf::ConstIterator *it = list->createIterator();
+ TemplateVariant v;
+ for (it->toFirst();it->current(v);it->toNext())
{
- //%% 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);
+ const TemplateStructIntf *s = v.toStruct();
+ TemplateVariant child = s->get("children");
+ int d = computeMaxDepth(child.toList())+1;
+ if (d>maxDepth) maxDepth=d;
}
- 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());
- }
+ delete it;
+ }
+ return maxDepth;
+}
- 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
+static int computeNumNodesAtLevel(const TemplateStructIntf *s,int level,int maxLevel)
+{
+ int num=0;
+ if (level<maxLevel)
+ {
+ num++;
+ TemplateVariant child = s->get("children");
+ if (child.toList())
{
- if (!m_cache.classContext)
+ TemplateListIntf::ConstIterator *it = child.toList()->createIterator();
+ TemplateVariant v;
+ for (it->toFirst();it->current(v);it->toNext())
{
- m_cache.classContext.reset(ClassContext::alloc(m_classDef));
+ num+=computeNumNodesAtLevel(v.toStruct(),level+1,maxLevel);
}
- return m_cache.classContext.get();
+ delete it;
}
- private:
- ClassDef *m_classDef;
- GenericNodeListContext m_children;
- struct Cachable
- {
- SharedPtr<ClassContext> classContext;
- };
- mutable Cachable m_cache;
-};
-//%% }
-
-ClassInheritanceNodeContext::ClassInheritanceNodeContext(ClassDef *cd) : RefCountedContext("ClassInheritanceNodeContext")
-{
- p = new Private(cd);
-}
-
-ClassInheritanceNodeContext::~ClassInheritanceNodeContext()
-{
- delete p;
-}
-
-TemplateVariant ClassInheritanceNodeContext::get(const char *n) const
-{
- return p->get(n);
-}
-
-void ClassInheritanceNodeContext::addChildren(const BaseClassList *bcl,bool hideSuper)
-{
- p->addChildren(bcl,hideSuper);
+ }
+ return num;
}
-//------------------------------------------------------------------------
-
-//%% list ClassInheritance[ClassInheritanceNode]: list of classes
-class ClassInheritanceContext::Private : public GenericNodeListContext
+static int computePreferredDepth(const TemplateListIntf *list,int maxDepth)
{
- public:
- void addClasses(const ClassSDict &classSDict)
+ int preferredNumEntries = Config_getInt("HTML_INDEX_NUM_ENTRIES");
+ int preferredDepth=1;
+ if (preferredNumEntries>0)
+ {
+ int depth = maxDepth;
+ for (int i=1;i<=depth;i++)
{
- ClassSDict::Iterator cli(classSDict);
- ClassDef *cd;
- for (cli.toFirst();(cd=cli.current());++cli)
+ int num=0;
+ TemplateListIntf::ConstIterator *it = list->createIterator();
+ TemplateVariant v;
+ for (it->toFirst();it->current(v);it->toNext())
{
- bool b;
- if (cd->getLanguage()==SrcLangExt_VHDL)
- {
- if ((VhdlDocGen::VhdlClasses)cd->protection()!=VhdlDocGen::ENTITYCLASS)
- {
- continue;
- }
- b=!hasVisibleRoot(cd->subClasses());
- }
- else
- {
- b=!hasVisibleRoot(cd->baseClasses());
- }
- if (b)
- {
- if (cd->isVisibleInHierarchy()) // should it be visible
- {
- // new root level class
- ClassInheritanceNodeContext *tnc = ClassInheritanceNodeContext::alloc(cd);
- append(tnc);
- bool hasChildren = !cd->visited && classHasVisibleChildren(cd);
- if (cd->getLanguage()==SrcLangExt_VHDL && hasChildren)
- {
- tnc->addChildren(cd->baseClasses(),cd->visited);
- cd->visited=TRUE;
- }
- else if (hasChildren)
- {
- tnc->addChildren(cd->subClasses(),cd->visited);
- cd->visited=TRUE;
- }
- }
- }
+ num+=computeNumNodesAtLevel(v.toStruct(),0,i);
+ }
+ delete it;
+ if (num<=preferredNumEntries)
+ {
+ preferredDepth=i;
+ }
+ else
+ {
+ break;
}
}
-};
-
-ClassInheritanceContext::ClassInheritanceContext() : RefCountedContext("ClassInheritanceContext")
-{
- p = new Private;
- initClassHierarchy(Doxygen::classSDict);
- initClassHierarchy(Doxygen::hiddenClasses);
- p->addClasses(*Doxygen::classSDict);
- p->addClasses(*Doxygen::hiddenClasses);
-}
-
-ClassInheritanceContext::~ClassInheritanceContext()
-{
- delete p;
-}
-
-// TemplateListIntf
-int ClassInheritanceContext::count() const
-{
- return (int)p->count();
-}
-
-TemplateVariant ClassInheritanceContext::at(int index) const
-{
- TemplateVariant result;
- if (index>=0 && index<count())
- {
- result = p->at(index);
}
- return result;
-}
-
-TemplateListIntf::ConstIterator *ClassInheritanceContext::createIterator() const
-{
- return p->createIterator();
+ return preferredDepth;
}
//------------------------------------------------------------------------
@@ -5019,13 +4917,27 @@ TemplateListIntf::ConstIterator *ClassInheritanceContext::createIterator() const
class ClassHierarchyContext::Private : public PropertyMapper
{
public:
+ Private()
+ {
+ m_classTree.reset(NestingContext::alloc(0,0));
+ initClassHierarchy(Doxygen::classSDict);
+ initClassHierarchy(Doxygen::hiddenClasses);
+ m_classTree->addClassHierarchy(*Doxygen::classSDict,TRUE);
+ m_classTree->addClassHierarchy(*Doxygen::hiddenClasses,TRUE);
+ //%% ClassInheritance 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);
+ addProperty("diagrams", this,&Private::diagrams);
+ }
TemplateVariant tree() const
{
- if (!m_cache.classTree)
- {
- m_cache.classTree.reset(ClassInheritanceContext::alloc());
- }
- return m_cache.classTree.get();
+ return m_classTree.get();
}
TemplateVariant fileName() const
{
@@ -5043,6 +4955,34 @@ class ClassHierarchyContext::Private : public PropertyMapper
{
return "classhierarchy";
}
+ DotGfxHierarchyTable *getHierarchy() const
+ {
+ if (!m_cache.hierarchy)
+ {
+ m_cache.hierarchy.reset(new DotGfxHierarchyTable());
+ }
+ return m_cache.hierarchy.get();
+ }
+ TemplateVariant diagrams() const
+ {
+ if (!m_cache.diagrams)
+ {
+ TemplateList *diagrams = TemplateList::alloc();
+ DotGfxHierarchyTable *hierarchy = getHierarchy();
+ if (hierarchy->subGraphs())
+ {
+ int id=0;
+ QListIterator<DotNode> li(*hierarchy->subGraphs());
+ DotNode *n;
+ for (li.toFirst();(n=li.current());++li)
+ {
+ diagrams->append(InheritanceGraphContext::alloc(hierarchy,n,id++));
+ }
+ }
+ m_cache.diagrams.reset(diagrams);
+ }
+ return m_cache.diagrams.get();
+ }
TemplateVariant title() const
{
static bool vhdlOpt = Config_getBool("OPTIMIZE_OUTPUT_VHDL");
@@ -5055,20 +4995,36 @@ class ClassHierarchyContext::Private : public PropertyMapper
return theTranslator->trClassHierarchy();
}
}
- Private()
+ TemplateVariant maxDepth() const
{
- //%% ClassInheritance 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);
+ if (!m_cache.maxDepthComputed)
+ {
+ m_cache.maxDepth = computeMaxDepth(m_classTree.get());
+ m_cache.maxDepthComputed=TRUE;
+ }
+ return m_cache.maxDepth;
+ }
+ TemplateVariant preferredDepth() const
+ {
+ if (!m_cache.preferredDepthComputed)
+ {
+ m_cache.preferredDepth = computePreferredDepth(m_classTree.get(),maxDepth().toInt());
+ m_cache.preferredDepthComputed=TRUE;
+ }
+ return m_cache.preferredDepth;
}
private:
+ SharedPtr<NestingContext> m_classTree;
struct Cachable
{
- SharedPtr<ClassInheritanceContext> classTree;
+ Cachable() : maxDepth(0), maxDepthComputed(FALSE),
+ preferredDepth(0), preferredDepthComputed(FALSE), hierarchy(0) {}
+ int maxDepth;
+ bool maxDepthComputed;
+ int preferredDepth;
+ bool preferredDepthComputed;
+ SharedPtr<TemplateList> diagrams;
+ ScopedPtr<DotGfxHierarchyTable> hierarchy;
};
mutable Cachable m_cache;
};
@@ -5097,7 +5053,7 @@ class NestingNodeContext::Private : public PropertyMapper
{
public:
Private(const NestingNodeContext *parent,const NestingNodeContext *thisNode,
- Definition *d,int index,int level,bool addCls)
+ Definition *d,int index,int level,bool addCls,bool inherit, bool hideSuper)
: m_parent(parent), m_def(d), m_level(level), m_index(index)
{
m_children.reset(NestingContext::alloc(thisNode,level+1));
@@ -5131,7 +5087,7 @@ class NestingNodeContext::Private : public PropertyMapper
addProperty("fileName",this,&Private::fileName);
addNamespaces(addCls);
- addClasses();
+ addClasses(inherit,hideSuper);
addDirFiles();
addPages();
addModules();
@@ -5283,12 +5239,34 @@ class NestingNodeContext::Private : public PropertyMapper
return m_def->getOutputFileBase();
}
- void addClasses()
+ //------------------------------------------------------------------
+
+ void addClasses(bool inherit, bool hideSuper)
{
ClassDef *cd = m_def->definitionType()==Definition::TypeClass ? (ClassDef*)m_def : 0;
- if (cd && cd->getClassSDict())
+ if (inherit)
{
- m_children->addClasses(*cd->getClassSDict(),FALSE);
+ bool hasChildren = !cd->visited && !hideSuper && classHasVisibleChildren(cd);
+ if (hasChildren)
+ {
+ bool wasVisited=cd->visited;
+ cd->visited=TRUE;
+ if (cd->getLanguage()==SrcLangExt_VHDL)
+ {
+ m_children->addDerivedClasses(cd->baseClasses(),wasVisited);
+ }
+ else
+ {
+ m_children->addDerivedClasses(cd->subClasses(),wasVisited);
+ }
+ }
+ }
+ else
+ {
+ if (cd && cd->getClassSDict())
+ {
+ m_children->addClasses(*cd->getClassSDict(),FALSE);
+ }
}
}
void addNamespaces(bool addClasses)
@@ -5352,9 +5330,10 @@ class NestingNodeContext::Private : public PropertyMapper
//%% }
NestingNodeContext::NestingNodeContext(const NestingNodeContext *parent,
- Definition *d,int index,int level,bool addClass) : RefCountedContext("NestingNodeContext")
+ Definition *d,int index,int level,bool addClass,bool inherit,bool hideSuper)
+ : RefCountedContext("NestingNodeContext")
{
- p = new Private(parent,this,d,index,level,addClass);
+ p = new Private(parent,this,d,index,level,addClass,inherit,hideSuper);
}
NestingNodeContext::~NestingNodeContext()
@@ -5394,7 +5373,7 @@ class NestingContext::Private : public GenericNodeListContext
bool isLinkable = nd->isLinkableInProject();
if (isLinkable || hasChildren)
{
- NestingNodeContext *nnc = NestingNodeContext::alloc(m_parent,nd,m_index,m_level,addClasses);
+ NestingNodeContext *nnc = NestingNodeContext::alloc(m_parent,nd,m_index,m_level,addClasses,FALSE,FALSE);
append(nnc);
m_index++;
}
@@ -5423,7 +5402,7 @@ class NestingContext::Private : public GenericNodeListContext
{
if (classVisibleInIndex(cd) && cd->templateMaster()==0)
{
- NestingNodeContext *nnc = NestingNodeContext::alloc(m_parent,cd,m_index,m_level,TRUE);
+ NestingNodeContext *nnc = NestingNodeContext::alloc(m_parent,cd,m_index,m_level,TRUE,FALSE,FALSE);
append(nnc);
m_index++;
}
@@ -5438,7 +5417,7 @@ class NestingContext::Private : public GenericNodeListContext
{
if (dd->getOuterScope()==Doxygen::globalScope)
{
- append(NestingNodeContext::alloc(m_parent,dd,m_index,m_level,FALSE));
+ append(NestingNodeContext::alloc(m_parent,dd,m_index,m_level,FALSE,FALSE,FALSE));
m_index++;
}
}
@@ -5449,7 +5428,7 @@ class NestingContext::Private : public GenericNodeListContext
DirDef *dd;
for (li.toFirst();(dd=li.current());++li)
{
- append(NestingNodeContext::alloc(m_parent,dd,m_index,m_level,FALSE));
+ append(NestingNodeContext::alloc(m_parent,dd,m_index,m_level,FALSE,FALSE,FALSE));
m_index++;
}
}
@@ -5465,7 +5444,7 @@ class NestingContext::Private : public GenericNodeListContext
{
if (fd->getDirDef()==0) // top level file
{
- append(NestingNodeContext::alloc(m_parent,fd,m_index,m_level,FALSE));
+ append(NestingNodeContext::alloc(m_parent,fd,m_index,m_level,FALSE,FALSE,FALSE));
m_index++;
}
}
@@ -5477,7 +5456,7 @@ class NestingContext::Private : public GenericNodeListContext
FileDef *fd;
for (li.toFirst();(fd=li.current());++li)
{
- append(NestingNodeContext::alloc(m_parent,fd,m_index,m_level,FALSE));
+ append(NestingNodeContext::alloc(m_parent,fd,m_index,m_level,FALSE,FALSE,FALSE));
m_index++;
}
}
@@ -5491,7 +5470,7 @@ class NestingContext::Private : public GenericNodeListContext
pd->getOuterScope()==0 ||
pd->getOuterScope()->definitionType()!=Definition::TypePage)
{
- append(NestingNodeContext::alloc(m_parent,pd,m_index,m_level,FALSE));
+ append(NestingNodeContext::alloc(m_parent,pd,m_index,m_level,FALSE,FALSE,FALSE));
m_index++;
}
}
@@ -5507,7 +5486,7 @@ class NestingContext::Private : public GenericNodeListContext
(!gd->isReference() || externalGroups)
)
{
- append(NestingNodeContext::alloc(m_parent,gd,m_index,m_level,FALSE));
+ append(NestingNodeContext::alloc(m_parent,gd,m_index,m_level,FALSE,FALSE,FALSE));
m_index++;
}
}
@@ -5520,11 +5499,74 @@ class NestingContext::Private : public GenericNodeListContext
{
if (gd->isVisible())
{
- append(NestingNodeContext::alloc(m_parent,gd,m_index,m_level,FALSE));
+ append(NestingNodeContext::alloc(m_parent,gd,m_index,m_level,FALSE,FALSE,FALSE));
m_index++;
}
}
}
+ void addDerivedClasses(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)
+ {
+ NestingNodeContext *tnc = NestingNodeContext::alloc(m_parent,cd,m_index,m_level,TRUE,TRUE,hideSuper);
+ append(tnc);
+ m_index++;
+ }
+ }
+ }
+ void addClassHierarchy(const ClassSDict &classSDict,bool)
+ {
+ ClassSDict::Iterator cli(classSDict);
+ ClassDef *cd;
+ for (cli.toFirst();(cd=cli.current());++cli)
+ {
+ bool b;
+ if (cd->getLanguage()==SrcLangExt_VHDL)
+ {
+ if ((VhdlDocGen::VhdlClasses)cd->protection()!=VhdlDocGen::ENTITYCLASS)
+ {
+ continue;
+ }
+ b=!hasVisibleRoot(cd->subClasses());
+ }
+ else
+ {
+ b=!hasVisibleRoot(cd->baseClasses());
+ }
+ if (b)
+ {
+ if (cd->isVisibleInHierarchy()) // should it be visible
+ {
+ // new root level class
+ NestingNodeContext *nnc = NestingNodeContext::alloc(m_parent,cd,m_index,m_level,TRUE,TRUE,cd->visited);
+ append(nnc);
+ m_index++;
+ }
+ }
+ }
+ }
+
private:
const NestingNodeContext *m_parent;
int m_level;
@@ -5602,78 +5644,17 @@ void NestingContext::addModules(const GroupList &modules)
p->addModules(modules);
}
-//------------------------------------------------------------------------
-
-static int computeMaxDepth(const TemplateListIntf *list)
+void NestingContext::addClassHierarchy(const ClassSDict &classSDict,bool rootOnly)
{
- int maxDepth=0;
- if (list)
- {
- TemplateListIntf::ConstIterator *it = list->createIterator();
- TemplateVariant v;
- for (it->toFirst();it->current(v);it->toNext())
- {
- const TemplateStructIntf *s = v.toStruct();
- TemplateVariant child = s->get("children");
- int d = computeMaxDepth(child.toList())+1;
- if (d>maxDepth) maxDepth=d;
- }
- delete it;
- }
- return maxDepth;
+ p->addClassHierarchy(classSDict,rootOnly);
}
-static int computeNumNodesAtLevel(const TemplateStructIntf *s,int level,int maxLevel)
+void NestingContext::addDerivedClasses(const BaseClassList *bcl,bool hideSuper)
{
- int num=0;
- if (level<maxLevel)
- {
- num++;
- TemplateVariant child = s->get("children");
- if (child.toList())
- {
- TemplateListIntf::ConstIterator *it = child.toList()->createIterator();
- TemplateVariant v;
- for (it->toFirst();it->current(v);it->toNext())
- {
- num+=computeNumNodesAtLevel(v.toStruct(),level+1,maxLevel);
- }
- delete it;
- }
- }
- return num;
-}
-
-static int computePreferredDepth(const TemplateListIntf *list,int maxDepth)
-{
- int preferredNumEntries = Config_getInt("HTML_INDEX_NUM_ENTRIES");
- int preferredDepth=1;
- if (preferredNumEntries>0)
- {
- int depth = maxDepth;
- for (int i=1;i<=depth;i++)
- {
- int num=0;
- TemplateListIntf::ConstIterator *it = list->createIterator();
- TemplateVariant v;
- for (it->toFirst();it->current(v);it->toNext())
- {
- num+=computeNumNodesAtLevel(v.toStruct(),0,i);
- }
- delete it;
- if (num<=preferredNumEntries)
- {
- preferredDepth=i;
- }
- else
- {
- break;
- }
- }
- }
- return preferredDepth;
+ p->addDerivedClasses(bcl,hideSuper);
}
+//------------------------------------------------------------------------
//%% struct ClassTree: Class nesting relations
//%% {
@@ -7049,6 +7030,56 @@ TemplateVariant NamespaceMembersIndexContext::get(const char *name) const
return p->get(name);
}
+//------------------------------------------------------------------------
+
+//%% struct InheritanceGraph: a connected graph reprenting part of the overall interitance tree
+//%% {
+class InheritanceGraphContext::Private : public PropertyMapper
+{
+ public:
+ Private(DotGfxHierarchyTable *hierarchy,DotNode *n,int id) : m_hierarchy(hierarchy), m_node(n), m_id(id)
+ {
+ addProperty("graph",this,&Private::graph);
+ }
+ TemplateVariant graph() const
+ {
+ QGString result;
+ static bool haveDot = Config_getBool("HAVE_DOT");
+ static bool graphicalHierarchy = Config_getBool("GRAPHICAL_HIERARCHY");
+ if (haveDot && graphicalHierarchy)
+ {
+ FTextStream t(&result);
+ m_hierarchy->createGraph(m_node,t,
+ /*GOF_BITMAP,
+ EOF_Html,*/
+ g_globals.outputDir,
+ g_globals.outputDir+portable_pathSeparator()+"inherits"+Doxygen::htmlFileExtension,
+ m_id);
+ }
+ return TemplateVariant(result.data(),TRUE);
+ }
+ private:
+ DotGfxHierarchyTable *m_hierarchy;
+ DotNode *m_node;
+ int m_id;
+};
+
+InheritanceGraphContext::InheritanceGraphContext(DotGfxHierarchyTable *hierarchy,DotNode *n,int id)
+ : RefCountedContext("InheritanceGraphContext")
+{
+ p = new Private(hierarchy,n,id);
+}
+
+InheritanceGraphContext::~InheritanceGraphContext()
+{
+ delete p;
+}
+
+TemplateVariant InheritanceGraphContext::get(const char *name) const
+{
+ return p->get(name);
+}
+
//------------------------------------------------------------------------
@@ -8086,7 +8117,7 @@ class HtmlSpaceless : public TemplateSpacelessIntf
{
m_insideString='\0';
}
- else // start of string
+ else if (m_insideString=='\0') // start of string
{
m_insideString=c;
}
@@ -8111,8 +8142,8 @@ class HtmlSpaceless : public TemplateSpacelessIntf
}
}
result+='\0';
- //printf("HtmlSpaceless::remove({%s})={%s} m_insideTag=%d m_insideString=%d removeSpaces=%d\n",s.data(),result.data(),
- // m_insideTag,m_insideString,m_removeSpaces);
+ //printf("HtmlSpaceless::remove({%s})={%s} m_insideTag=%d m_insideString=%c (%d) removeSpaces=%d\n",s.data(),result.data(),
+ // m_insideTag,m_insideString,m_insideString,m_removeSpaces);
return result.data();
}
private: