Added graphical hierarchy support to template engine

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: