Added *.ice files as a recognized file type.

Added a Slice-optimized output mode.

1 files changed, 852 insertions, 60 deletions

diff --git a/src/index.cpp b/src/index.cpp
index 8be6b24..fd2d1d8 100644
--- a/src/index.cpp
+++ b/src/index.cpp
@@ -56,6 +56,14 @@
 int annotatedClasses;
 int annotatedClassesPrinted;
 int hierarchyClasses;
+int annotatedInterfaces;
+int annotatedInterfacesPrinted;
+int hierarchyInterfaces;
+int annotatedStructs;
+int annotatedStructsPrinted;
+int annotatedExceptions;
+int annotatedExceptionsPrinted;
+int hierarchyExceptions;
 int documentedFiles;
 int documentedGroups;
 int documentedNamespaces;
@@ -67,23 +75,34 @@ int documentedHtmlFiles;
 int documentedPages;
 int documentedDirs;
 
-static int countClassHierarchy();
+static int countClassHierarchy(ClassDef::CompoundType ct);
 static void countFiles(int &htmlFiles,int &files);
 static int countGroups();
 static int countDirs();
 static int countNamespaces();
-static int countAnnotatedClasses(int *cp);
+static int countAnnotatedClasses(int *cp,ClassDef::CompoundType ct);
 static void countRelatedPages(int &docPages,int &indexPages);
 
 void countDataStructures()
 {
-  annotatedClasses           = countAnnotatedClasses(&annotatedClassesPrinted); // "classes" + "annotated"
-  hierarchyClasses           = countClassHierarchy();   // "hierarchy"
-  countFiles(documentedHtmlFiles,documentedFiles);      // "files"
-  countRelatedPages(documentedPages,indexedPages);      // "pages"
-  documentedGroups           = countGroups();           // "modules"
-  documentedNamespaces       = countNamespaces();       // "namespaces"
-  documentedDirs             = countDirs();             // "dirs"
+  static bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
+  annotatedClasses           = countAnnotatedClasses(&annotatedClassesPrinted, ClassDef::Class); // "classes" + "annotated"
+  hierarchyClasses           = countClassHierarchy(ClassDef::Class);     // "hierarchy"
+  // "interfaces" + "annotated"
+  annotatedInterfaces        = sliceOpt ? countAnnotatedClasses(&annotatedInterfacesPrinted, ClassDef::Interface) : 0;
+  // "interfacehierarchy"
+  hierarchyInterfaces        = sliceOpt ? countClassHierarchy(ClassDef::Interface) : 0;
+  // "structs" + "annotated"
+  annotatedStructs           = sliceOpt ? countAnnotatedClasses(&annotatedStructsPrinted, ClassDef::Struct) : 0;
+  // "exceptions" + "annotated"
+  annotatedExceptions        = sliceOpt ? countAnnotatedClasses(&annotatedExceptionsPrinted, ClassDef::Exception) : 0;
+  // "exceptionhierarchy"
+  hierarchyExceptions        = sliceOpt ? countClassHierarchy(ClassDef::Exception) : 0;
+  countFiles(documentedHtmlFiles,documentedFiles);        // "files"
+  countRelatedPages(documentedPages,indexedPages);        // "pages"
+  documentedGroups           = countGroups();             // "modules"
+  documentedNamespaces       = countNamespaces();         // "namespaces"
+  documentedDirs             = countDirs();               // "dirs"
   // "globals"
   // "namespacemembers"
   // "functions"
@@ -805,8 +824,10 @@ static void writeDirHierarchy(OutputList &ol, FTVHelp* ftv,bool addToIndex)
 
 //----------------------------------------------------------------------------
 
-static void writeClassTreeForList(OutputList &ol,ClassSDict *cl,bool &started,FTVHelp* ftv,bool addToIndex)
+static void writeClassTreeForList(OutputList &ol,ClassSDict *cl,bool &started,FTVHelp* ftv,bool addToIndex,
+                                  ClassDef::CompoundType ct)
 {
+  static bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
   ClassSDict::Iterator cli(*cl);
   ClassDef *cd;
   for (;(cd=cli.current());++cli)
@@ -825,6 +846,10 @@ static void writeClassTreeForList(OutputList &ol,ClassSDict *cl,bool &started,FT
       }
       b=!hasVisibleRoot(cd->subClasses());
     }
+    else if (sliceOpt && cd->compoundType() != ct)
+    {
+      continue;
+    }
     else
     {
       b=!hasVisibleRoot(cd->baseClasses());
@@ -899,7 +924,7 @@ static void writeClassTreeForList(OutputList &ol,ClassSDict *cl,bool &started,FT
   }
 }
 
-static void writeClassHierarchy(OutputList &ol, FTVHelp* ftv,bool addToIndex)
+static void writeClassHierarchy(OutputList &ol, FTVHelp* ftv,bool addToIndex,ClassDef::CompoundType ct)
 {
   initClassHierarchy(Doxygen::classSDict);
   initClassHierarchy(Doxygen::hiddenClasses);
@@ -909,8 +934,8 @@ static void writeClassHierarchy(OutputList &ol, FTVHelp* ftv,bool addToIndex)
     ol.disable(OutputGenerator::Html);
   }
   bool started=FALSE;
-  writeClassTreeForList(ol,Doxygen::classSDict,started,ftv,addToIndex);
-  writeClassTreeForList(ol,Doxygen::hiddenClasses,started,ftv,addToIndex);
+  writeClassTreeForList(ol,Doxygen::classSDict,started,ftv,addToIndex,ct);
+  writeClassTreeForList(ol,Doxygen::hiddenClasses,started,ftv,addToIndex,ct);
   if (started)
   {
     endIndexHierarchy(ol,0);
@@ -927,13 +952,18 @@ static void writeClassHierarchy(OutputList &ol, FTVHelp* ftv,bool addToIndex)
 
 //----------------------------------------------------------------------------
 
-static int countClassesInTreeList(const ClassSDict &cl)
+static int countClassesInTreeList(const ClassSDict &cl, ClassDef::CompoundType ct)
 {
+  static bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
   int count=0;
   ClassSDict::Iterator cli(cl);
   ClassDef *cd;
   for (;(cd=cli.current());++cli)
   {
+    if (sliceOpt && cd->compoundType() != ct)
+    {
+      continue;
+    }
     if (!hasVisibleRoot(cd->baseClasses())) // filter on root classes
     {
       if (cd->isVisibleInHierarchy()) // should it be visible
@@ -948,13 +978,13 @@ static int countClassesInTreeList(const ClassSDict &cl)
   return count;
 }
 
-static int countClassHierarchy()
+static int countClassHierarchy(ClassDef::CompoundType ct)
 {
   int count=0;
   initClassHierarchy(Doxygen::classSDict);
   initClassHierarchy(Doxygen::hiddenClasses);
-  count+=countClassesInTreeList(*Doxygen::classSDict);
-  count+=countClassesInTreeList(*Doxygen::hiddenClasses);
+  count+=countClassesInTreeList(*Doxygen::classSDict, ct);
+  count+=countClassesInTreeList(*Doxygen::hiddenClasses, ct);
   return count;
 }
 
@@ -972,7 +1002,7 @@ static void writeHierarchicalIndex(OutputList &ol)
   QCString title = lne ? lne->title() : theTranslator->trClassHierarchy();
   bool addToIndex = lne==0 || lne->visible();
 
-  startFile(ol,"hierarchy",0, title, HLI_Hierarchy);
+  startFile(ol,"hierarchy",0, title, HLI_ClassHierarchy);
   startTitle(ol,0);
   ol.parseText(title);
   endTitle(ol,0,0);
@@ -1003,7 +1033,7 @@ static void writeHierarchicalIndex(OutputList &ol)
   ol.disable(OutputGenerator::Html);
   Doxygen::indexList->disable();
 
-  writeClassHierarchy(ol,0,addToIndex);
+  writeClassHierarchy(ol,0,addToIndex,ClassDef::Class);
 
   Doxygen::indexList->enable();
   ol.popGeneratorState();
@@ -1022,7 +1052,7 @@ static void writeHierarchicalIndex(OutputList &ol)
       Doxygen::indexList->addContentsItem(TRUE,title,0,"hierarchy",0,TRUE,TRUE);
     }
     FTVHelp* ftv = new FTVHelp(FALSE);
-    writeClassHierarchy(ol,ftv,addToIndex);
+    writeClassHierarchy(ol,ftv,addToIndex,ClassDef::Class);
     QGString outStr;
     FTextStream t(&outStr);
     ftv->generateTreeViewInline(t);
@@ -1049,7 +1079,7 @@ static void writeGraphicalClassHierarchy(OutputList &ol)
   ol.disableAllBut(OutputGenerator::Html);
   LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassHierarchy);
   QCString title = lne ? lne->title() : theTranslator->trClassHierarchy();
-  startFile(ol,"inherits",0,title,HLI_Hierarchy,FALSE,"hierarchy");
+  startFile(ol,"inherits",0,title,HLI_ClassHierarchy,FALSE,"hierarchy");
   startTitle(ol,0);
   ol.parseText(title);
   endTitle(ol,0,0);
@@ -1069,6 +1099,220 @@ static void writeGraphicalClassHierarchy(OutputList &ol)
 
 //----------------------------------------------------------------------------
 
+static void writeHierarchicalInterfaceIndex(OutputList &ol)
+{
+  if (hierarchyInterfaces==0) return;
+  ol.pushGeneratorState();
+  //1.{
+  ol.disable(OutputGenerator::Man);
+
+  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::InterfaceHierarchy);
+  QCString title = lne ? lne->title() : theTranslator->trInterfaceHierarchy();
+  bool addToIndex = lne==0 || lne->visible();
+
+  startFile(ol,"interfacehierarchy",0, title, HLI_InterfaceHierarchy);
+  startTitle(ol,0);
+  ol.parseText(title);
+  endTitle(ol,0,0);
+  ol.startContents();
+  ol.startTextBlock();
+
+  if (Config_getBool(HAVE_DOT) && Config_getBool(GRAPHICAL_HIERARCHY))
+  {
+    ol.disable(OutputGenerator::Latex);
+    ol.disable(OutputGenerator::RTF);
+    ol.startParagraph();
+    ol.startTextLink("interfaceinherits",0);
+    ol.parseText(theTranslator->trGotoGraphicalHierarchy());
+    ol.endTextLink();
+    ol.endParagraph();
+    ol.enable(OutputGenerator::Latex);
+    ol.enable(OutputGenerator::RTF);
+  }
+  ol.parseText(lne ? lne->intro() : theTranslator->trInterfaceHierarchyDescription());
+  ol.endTextBlock();
+
+  // ---------------
+  // Static interface hierarchy for Latex/RTF
+  // ---------------
+  ol.pushGeneratorState();
+  //2.{
+  ol.disable(OutputGenerator::Html);
+  Doxygen::indexList->disable();
+
+  writeClassHierarchy(ol,0,addToIndex,ClassDef::Interface);
+
+  Doxygen::indexList->enable();
+  ol.popGeneratorState();
+  //2.}
+
+  // ---------------
+  // Dynamic interface hierarchical index for HTML
+  // ---------------
+  ol.pushGeneratorState();
+  //2.{
+  ol.disableAllBut(OutputGenerator::Html);
+
+  {
+    if (addToIndex)
+    {
+      Doxygen::indexList->addContentsItem(TRUE,title,0,"interfacehierarchy",0,TRUE,TRUE);
+    }
+    FTVHelp* ftv = new FTVHelp(FALSE);
+    writeClassHierarchy(ol,ftv,addToIndex,ClassDef::Interface);
+    QGString outStr;
+    FTextStream t(&outStr);
+    ftv->generateTreeViewInline(t);
+    ol.pushGeneratorState();
+    ol.disableAllBut(OutputGenerator::Html);
+    ol.writeString(outStr);
+    ol.popGeneratorState();
+    delete ftv;
+  }
+  ol.popGeneratorState();
+  //2.}
+  // ------
+
+  endFile(ol);
+  ol.popGeneratorState();
+  //1.}
+}
+
+//----------------------------------------------------------------------------
+
+static void writeGraphicalInterfaceHierarchy(OutputList &ol)
+{
+  if (hierarchyInterfaces==0) return;
+  ol.disableAllBut(OutputGenerator::Html);
+  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::InterfaceHierarchy);
+  QCString title = lne ? lne->title() : theTranslator->trInterfaceHierarchy();
+  startFile(ol,"interfaceinherits",0,title,HLI_InterfaceHierarchy,FALSE,"interfacehierarchy");
+  startTitle(ol,0);
+  ol.parseText(title);
+  endTitle(ol,0,0);
+  ol.startContents();
+  ol.startTextBlock();
+  ol.startParagraph();
+  ol.startTextLink("interfacehierarchy",0);
+  ol.parseText(theTranslator->trGotoTextualHierarchy());
+  ol.endTextLink();
+  ol.endParagraph();
+  ol.endTextBlock();
+  DotGfxHierarchyTable g("interface_",ClassDef::Interface);
+  ol.writeGraphicalHierarchy(g);
+  endFile(ol);
+  ol.enableAll();
+}
+
+//----------------------------------------------------------------------------
+
+static void writeHierarchicalExceptionIndex(OutputList &ol)
+{
+  if (hierarchyExceptions==0) return;
+  ol.pushGeneratorState();
+  //1.{
+  ol.disable(OutputGenerator::Man);
+
+  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ExceptionHierarchy);
+  QCString title = lne ? lne->title() : theTranslator->trExceptionHierarchy();
+  bool addToIndex = lne==0 || lne->visible();
+
+  startFile(ol,"exceptionhierarchy",0, title, HLI_ExceptionHierarchy);
+  startTitle(ol,0);
+  ol.parseText(title);
+  endTitle(ol,0,0);
+  ol.startContents();
+  ol.startTextBlock();
+
+  if (Config_getBool(HAVE_DOT) && Config_getBool(GRAPHICAL_HIERARCHY))
+  {
+    ol.disable(OutputGenerator::Latex);
+    ol.disable(OutputGenerator::RTF);
+    ol.startParagraph();
+    ol.startTextLink("exceptioninherits",0);
+    ol.parseText(theTranslator->trGotoGraphicalHierarchy());
+    ol.endTextLink();
+    ol.endParagraph();
+    ol.enable(OutputGenerator::Latex);
+    ol.enable(OutputGenerator::RTF);
+  }
+  ol.parseText(lne ? lne->intro() : theTranslator->trExceptionHierarchyDescription());
+  ol.endTextBlock();
+
+  // ---------------
+  // Static exception hierarchy for Latex/RTF
+  // ---------------
+  ol.pushGeneratorState();
+  //2.{
+  ol.disable(OutputGenerator::Html);
+  Doxygen::indexList->disable();
+
+  writeClassHierarchy(ol,0,addToIndex,ClassDef::Exception);
+
+  Doxygen::indexList->enable();
+  ol.popGeneratorState();
+  //2.}
+
+  // ---------------
+  // Dynamic exception hierarchical index for HTML
+  // ---------------
+  ol.pushGeneratorState();
+  //2.{
+  ol.disableAllBut(OutputGenerator::Html);
+
+  {
+    if (addToIndex)
+    {
+      Doxygen::indexList->addContentsItem(TRUE,title,0,"exceptionhierarchy",0,TRUE,TRUE);
+    }
+    FTVHelp* ftv = new FTVHelp(FALSE);
+    writeClassHierarchy(ol,ftv,addToIndex,ClassDef::Exception);
+    QGString outStr;
+    FTextStream t(&outStr);
+    ftv->generateTreeViewInline(t);
+    ol.pushGeneratorState();
+    ol.disableAllBut(OutputGenerator::Html);
+    ol.writeString(outStr);
+    ol.popGeneratorState();
+    delete ftv;
+  }
+  ol.popGeneratorState();
+  //2.}
+  // ------
+
+  endFile(ol);
+  ol.popGeneratorState();
+  //1.}
+}
+
+//----------------------------------------------------------------------------
+
+static void writeGraphicalExceptionHierarchy(OutputList &ol)
+{
+  if (hierarchyExceptions==0) return;
+  ol.disableAllBut(OutputGenerator::Html);
+  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ExceptionHierarchy);
+  QCString title = lne ? lne->title() : theTranslator->trExceptionHierarchy();
+  startFile(ol,"exceptioninherits",0,title,HLI_ExceptionHierarchy,FALSE,"exceptionhierarchy");
+  startTitle(ol,0);
+  ol.parseText(title);
+  endTitle(ol,0,0);
+  ol.startContents();
+  ol.startTextBlock();
+  ol.startParagraph();
+  ol.startTextLink("exceptionhierarchy",0);
+  ol.parseText(theTranslator->trGotoTextualHierarchy());
+  ol.endTextLink();
+  ol.endParagraph();
+  ol.endTextBlock();
+  DotGfxHierarchyTable g("exception_",ClassDef::Exception);
+  ol.writeGraphicalHierarchy(g);
+  endFile(ol);
+  ol.enableAll();
+}
+
+//----------------------------------------------------------------------------
+
 static void countFiles(int &htmlFiles,int &files)
 {
   htmlFiles=0;
@@ -1327,8 +1571,9 @@ static int countNamespaces()
 
 //----------------------------------------------------------------------------
 
-void writeClassTree(ClassSDict *clDict,FTVHelp *ftv,bool addToIndex,bool globalOnly)
+void writeClassTree(ClassSDict *clDict,FTVHelp *ftv,bool addToIndex,bool globalOnly,ClassDef::CompoundType ct)
 {
+  static bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
   if (clDict)
   {
     ClassSDict::Iterator cli(*clDict);
@@ -1350,6 +1595,11 @@ void writeClassTree(ClassSDict *clDict,FTVHelp *ftv,bool addToIndex,bool globalO
         }
       }
 
+      if (sliceOpt && cd->compoundType() != ct)
+      {
+        continue;
+      }
+
       if (!globalOnly ||
            cd->getOuterScope()==0 ||
            cd->getOuterScope()==Doxygen::globalScope
@@ -1387,7 +1637,7 @@ void writeClassTree(ClassSDict *clDict,FTVHelp *ftv,bool addToIndex,bool globalO
           if (count>0)
           {
             ftv->incContentsDepth();
-            writeClassTree(cd->getClassSDict(),ftv,addToIndex,FALSE);
+            writeClassTree(cd->getClassSDict(),ftv,addToIndex,FALSE,ct);
             ftv->decContentsDepth();
           }
         }
@@ -1397,8 +1647,9 @@ void writeClassTree(ClassSDict *clDict,FTVHelp *ftv,bool addToIndex,bool globalO
 }
 
 static void writeNamespaceTree(NamespaceSDict *nsDict,FTVHelp *ftv,
-                               bool rootOnly,bool showClasses,bool addToIndex)
+                               bool rootOnly,bool showClasses,bool addToIndex,ClassDef::CompoundType ct)
 {
+  static bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
   if (nsDict)
   {
     NamespaceSDict::Iterator nli(*nsDict);
@@ -1409,7 +1660,7 @@ static void writeNamespaceTree(NamespaceSDict *nsDict,FTVHelp *ftv,
           (!rootOnly || nd->getOuterScope()==Doxygen::globalScope))
       {
 
-        bool hasChildren = namespaceHasVisibleChild(nd,showClasses);
+        bool hasChildren = namespaceHasVisibleChild(nd,showClasses,sliceOpt,ct);
         bool isLinkable  = nd->isLinkableInProject();
 
         QCString ref;
@@ -1440,10 +1691,34 @@ static void writeNamespaceTree(NamespaceSDict *nsDict,FTVHelp *ftv,
           {
             if (addToIndex) Doxygen::indexList->incContentsDepth();
             ftv->incContentsDepth();
-            writeNamespaceTree(nd->getNamespaceSDict(),ftv,FALSE,showClasses,addToIndex);
+            writeNamespaceTree(nd->getNamespaceSDict(),ftv,FALSE,showClasses,addToIndex,ct);
             if (showClasses)
             {
-              writeClassTree(nd->getClassSDict(),ftv,addToIndex,FALSE);
+              ClassSDict *d;
+              if (sliceOpt)
+              {
+                if (ct == ClassDef::Interface)
+                {
+                  d = nd->getInterfaceSDict();
+                }
+                else if (ct == ClassDef::Struct)
+                {
+                  d = nd->getStructSDict();
+                }
+                else if (ct == ClassDef::Exception)
+                {
+                  d = nd->getExceptionSDict();
+                }
+                else
+                {
+                  d = nd->getClassSDict();
+                }
+              }
+              else
+              {
+                d = nd->getClassSDict();
+              }
+              writeClassTree(d,ftv,addToIndex,FALSE,ct);
             }
             ftv->decContentsDepth();
             if (addToIndex) Doxygen::indexList->decContentsDepth();
@@ -1543,7 +1818,7 @@ static void writeNamespaceIndex(OutputList &ol)
       Doxygen::indexList->incContentsDepth();
     }
     FTVHelp* ftv = new FTVHelp(FALSE);
-    writeNamespaceTree(Doxygen::namespaceSDict,ftv,TRUE,FALSE,addToIndex);
+    writeNamespaceTree(Doxygen::namespaceSDict,ftv,TRUE,FALSE,addToIndex,ClassDef::Class);
     QGString outStr;
     FTextStream t(&outStr);
     ftv->generateTreeViewInline(t);
@@ -1564,14 +1839,19 @@ static void writeNamespaceIndex(OutputList &ol)
 
 //----------------------------------------------------------------------------
 
-static int countAnnotatedClasses(int *cp)
+static int countAnnotatedClasses(int *cp, ClassDef::CompoundType ct)
 {
+  static bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
   int count=0;
   int countPrinted=0;
   ClassSDict::Iterator cli(*Doxygen::classSDict);
   ClassDef *cd;
   for (;(cd=cli.current());++cli)
   {
+    if (sliceOpt && cd->compoundType() != ct)
+    {
+      continue;
+    }
     if (cd->isLinkableInProject() && cd->templateMaster()==0)
     {
       if (!cd->isEmbeddedInOuterScope())
@@ -1586,12 +1866,15 @@ static int countAnnotatedClasses(int *cp)
 }
 
 
-static void writeAnnotatedClassList(OutputList &ol)
+static void writeAnnotatedClassList(OutputList &ol,ClassDef::CompoundType ct)
 {
   //LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassList);
   //bool addToIndex = lne==0 || lne->visible();
   bool first=TRUE;
 
+  static bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
+
+  ol.startIndexList();
   ClassSDict::Iterator cli(*Doxygen::classSDict);
   ClassDef *cd;
 
@@ -1610,6 +1893,11 @@ static void writeAnnotatedClassList(OutputList &ol)
       first=FALSE;
     }
 
+    if (sliceOpt && cd->compoundType() != ct)
+    {
+      continue;
+    }
+
     ol.pushGeneratorState();
     if (cd->isEmbeddedInOuterScope())
     {
@@ -1780,8 +2068,10 @@ class UsedIndexLetters : public SIntDict<uint>
 };
 
 // write an alphabetical index of all class with a header for each letter
-static void writeAlphabeticalClassList(OutputList &ol)
+static void writeAlphabeticalClassList(OutputList &ol, ClassDef::CompoundType ct, int annotatedCount)
 {
+  static bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
+
   // What starting letters are used
   UsedIndexLetters indexLettersUsed;
 
@@ -1792,6 +2082,8 @@ static void writeAlphabeticalClassList(OutputList &ol)
   int headerItems=0;
   for (;(cd=cli.current());++cli)
   {
+    if (sliceOpt && cd->compoundType() != ct)
+      continue;
     if (cd->isLinkableInProject() && cd->templateMaster()==0)
     {
       if (cd->getLanguage()==SrcLangExt_VHDL && !((VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::ENTITYCLASS ))// no architecture
@@ -1827,7 +2119,7 @@ static void writeAlphabeticalClassList(OutputList &ol)
   const int columns = Config_getInt(COLS_IN_ALPHA_INDEX);
 
   int i,j;
-  int totalItems = headerItems*2 + annotatedClasses;      // number of items in the table (headers span 2 items)
+  int totalItems = headerItems*2 + annotatedCount;        // number of items in the table (headers span 2 items)
   int rows = (totalItems + columns - 1)/columns;          // number of rows in the table
 
   //printf("headerItems=%d totalItems=%d columns=%d rows=%d itemsInLastRow=%d\n",
@@ -1844,6 +2136,8 @@ static void writeAlphabeticalClassList(OutputList &ol)
   startLetter=0;
   for (cli.toFirst();(cd=cli.current());++cli)
   {
+    if (sliceOpt && cd->compoundType() != ct)
+      continue;
     if (cd->getLanguage()==SrcLangExt_VHDL && !((VhdlDocGen::VhdlClasses)cd->protection()==VhdlDocGen::ENTITYCLASS ))// no architecture
       continue;
 
@@ -2033,7 +2327,6 @@ static void writeAlphabeticalIndex(OutputList &ol)
   if (annotatedClasses==0) return;
   ol.pushGeneratorState();
   ol.disableAllBut(OutputGenerator::Html);
-  ol.disable(OutputGenerator::Docbook);
   LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ClassIndex);
   QCString title = lne ? lne->title() : theTranslator->trCompoundIndex();
   bool addToIndex = lne==0 || lne->visible();
@@ -2050,7 +2343,94 @@ static void writeAlphabeticalIndex(OutputList &ol)
   }
 
   ol.startContents();
-  writeAlphabeticalClassList(ol);
+  writeAlphabeticalClassList(ol, ClassDef::Class, annotatedClasses);
+  endFile(ol); // contains ol.endContents()
+
+  ol.popGeneratorState();
+}
+
+//----------------------------------------------------------------------------
+
+static void writeAlphabeticalInterfaceIndex(OutputList &ol)
+{
+  if (annotatedInterfaces==0) return;
+  ol.pushGeneratorState();
+  ol.disableAllBut(OutputGenerator::Html);
+  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::InterfaceIndex);
+  QCString title = lne ? lne->title() : theTranslator->trInterfaceIndex();
+  bool addToIndex = lne==0 || lne->visible();
+
+  startFile(ol,"interfaces",0,title,HLI_Interfaces);
+
+  startTitle(ol,0);
+  ol.parseText(title);
+  endTitle(ol,0,0);
+
+  if (addToIndex)
+  {
+    Doxygen::indexList->addContentsItem(FALSE,title,0,"interfaces",0,FALSE,TRUE);
+  }
+
+  ol.startContents();
+  writeAlphabeticalClassList(ol, ClassDef::Interface, annotatedInterfaces);
+  endFile(ol); // contains ol.endContents()
+
+  ol.popGeneratorState();
+}
+
+//----------------------------------------------------------------------------
+
+static void writeAlphabeticalStructIndex(OutputList &ol)
+{
+  if (annotatedStructs==0) return;
+  ol.pushGeneratorState();
+  ol.disableAllBut(OutputGenerator::Html);
+  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::StructIndex);
+  QCString title = lne ? lne->title() : theTranslator->trStructIndex();
+  bool addToIndex = lne==0 || lne->visible();
+
+  startFile(ol,"structs",0,title,HLI_Structs);
+
+  startTitle(ol,0);
+  ol.parseText(title);
+  endTitle(ol,0,0);
+
+  if (addToIndex)
+  {
+    Doxygen::indexList->addContentsItem(FALSE,title,0,"structs",0,FALSE,TRUE);
+  }
+
+  ol.startContents();
+  writeAlphabeticalClassList(ol, ClassDef::Struct, annotatedStructs);
+  endFile(ol); // contains ol.endContents()
+
+  ol.popGeneratorState();
+}
+
+//----------------------------------------------------------------------------
+
+static void writeAlphabeticalExceptionIndex(OutputList &ol)
+{
+  if (annotatedExceptions==0) return;
+  ol.pushGeneratorState();
+  ol.disableAllBut(OutputGenerator::Html);
+  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ExceptionIndex);
+  QCString title = lne ? lne->title() : theTranslator->trExceptionIndex();
+  bool addToIndex = lne==0 || lne->visible();
+
+  startFile(ol,"exceptions",0,title,HLI_Exceptions);
+
+  startTitle(ol,0);
+  ol.parseText(title);
+  endTitle(ol,0,0);
+
+  if (addToIndex)
+  {
+    Doxygen::indexList->addContentsItem(FALSE,title,0,"exceptions",0,FALSE,TRUE);
+  }
+
+  ol.startContents();
+  writeAlphabeticalClassList(ol, ClassDef::Exception, annotatedExceptions);
   endFile(ol); // contains ol.endContents()
 
   ol.popGeneratorState();
@@ -2066,7 +2446,6 @@ static void writeAnnotatedIndex(OutputList &ol)
 
   ol.pushGeneratorState();
   ol.disable(OutputGenerator::Man);
-  ol.disable(OutputGenerator::Docbook);
   if (annotatedClassesPrinted==0)
   {
     ol.disable(OutputGenerator::Latex);
@@ -2078,7 +2457,7 @@ static void writeAnnotatedIndex(OutputList &ol)
   bool addToIndex = lne==0 || lne->visible();
 
 
-  startFile(ol,"annotated",0,title,HLI_Annotated);
+  startFile(ol,"annotated",0,title,HLI_AnnotatedClasses);
 
   startTitle(ol,0);
   ol.parseText(title);
@@ -2097,7 +2476,7 @@ static void writeAnnotatedIndex(OutputList &ol)
   ol.disable(OutputGenerator::Html);
   Doxygen::indexList->disable();
 
-  writeAnnotatedClassList(ol);
+  writeAnnotatedClassList(ol, ClassDef::Class);
 
   Doxygen::indexList->enable();
   ol.popGeneratorState();
@@ -2115,8 +2494,239 @@ static void writeAnnotatedIndex(OutputList &ol)
       Doxygen::indexList->incContentsDepth();
     }
     FTVHelp* ftv = new FTVHelp(FALSE);
-    writeNamespaceTree(Doxygen::namespaceSDict,ftv,TRUE,TRUE,addToIndex);
-    writeClassTree(Doxygen::classSDict,ftv,addToIndex,TRUE);
+    writeNamespaceTree(Doxygen::namespaceSDict,ftv,TRUE,TRUE,addToIndex,ClassDef::Class);
+    writeClassTree(Doxygen::classSDict,ftv,addToIndex,TRUE,ClassDef::Class);
+    QGString outStr;
+    FTextStream t(&outStr);
+    ftv->generateTreeViewInline(t);
+    ol.writeString(outStr);
+    delete ftv;
+    if (addToIndex)
+    {
+      Doxygen::indexList->decContentsDepth();
+    }
+  }
+
+  ol.popGeneratorState();
+  // ------
+
+  endFile(ol); // contains ol.endContents()
+  ol.popGeneratorState();
+}
+
+//----------------------------------------------------------------------------
+
+static void writeAnnotatedInterfaceIndex(OutputList &ol)
+{
+  //printf("writeAnnotatedInterfaceIndex: count=%d printed=%d\n",
+  //    annotatedInterfaces,annotatedInterfacesPrinted);
+  if (annotatedInterfaces==0) return;
+
+  ol.pushGeneratorState();
+  ol.disable(OutputGenerator::Man);
+  if (annotatedInterfacesPrinted==0)
+  {
+    ol.disable(OutputGenerator::Latex);
+    ol.disable(OutputGenerator::RTF);
+  }
+  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::InterfaceList);
+  if (lne==0) lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Interfaces); // fall back
+  QCString title = lne ? lne->title() : theTranslator->trInterfaceList();
+  bool addToIndex = lne==0 || lne->visible();
+
+  startFile(ol,"annotatedinterfaces",0,title,HLI_AnnotatedInterfaces);
+
+  startTitle(ol,0);
+  ol.parseText(title);
+  endTitle(ol,0,0);
+
+  ol.startContents();
+
+  ol.startTextBlock();
+  ol.parseText(lne ? lne->intro() : theTranslator->trInterfaceListDescription());
+  ol.endTextBlock();
+
+  // ---------------
+  // Linear interface index for Latex/RTF
+  // ---------------
+  ol.pushGeneratorState();
+  ol.disable(OutputGenerator::Html);
+  Doxygen::indexList->disable();
+
+  writeAnnotatedClassList(ol, ClassDef::Interface);
+
+  Doxygen::indexList->enable();
+  ol.popGeneratorState();
+
+  // ---------------
+  // Hierarchical interface index for HTML
+  // ---------------
+  ol.pushGeneratorState();
+  ol.disableAllBut(OutputGenerator::Html);
+
+  {
+    if (addToIndex)
+    {
+      Doxygen::indexList->addContentsItem(TRUE,title,0,"annotatedinterfaces",0,TRUE,TRUE);
+      Doxygen::indexList->incContentsDepth();
+    }
+    FTVHelp* ftv = new FTVHelp(FALSE);
+    writeNamespaceTree(Doxygen::namespaceSDict,ftv,TRUE,TRUE,addToIndex,ClassDef::Interface);
+    writeClassTree(Doxygen::classSDict,ftv,addToIndex,TRUE,ClassDef::Interface);
+    QGString outStr;
+    FTextStream t(&outStr);
+    ftv->generateTreeViewInline(t);
+    ol.writeString(outStr);
+    delete ftv;
+    if (addToIndex)
+    {
+      Doxygen::indexList->decContentsDepth();
+    }
+  }
+
+  ol.popGeneratorState();
+  // ------
+
+  endFile(ol); // contains ol.endContents()
+  ol.popGeneratorState();
+}
+
+//----------------------------------------------------------------------------
+
+static void writeAnnotatedStructIndex(OutputList &ol)
+{
+  //printf("writeAnnotatedStructIndex: count=%d printed=%d\n",
+  //    annotatedStructs,annotatedStructsPrinted);
+  if (annotatedStructs==0) return;
+
+  ol.pushGeneratorState();
+  ol.disable(OutputGenerator::Man);
+  if (annotatedStructsPrinted==0)
+  {
+    ol.disable(OutputGenerator::Latex);
+    ol.disable(OutputGenerator::RTF);
+  }
+  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::StructList);
+  if (lne==0) lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Structs); // fall back
+  QCString title = lne ? lne->title() : theTranslator->trStructList();
+  bool addToIndex = lne==0 || lne->visible();
+
+  startFile(ol,"annotatedstructs",0,title,HLI_AnnotatedStructs);
+
+  startTitle(ol,0);
+  ol.parseText(title);
+  endTitle(ol,0,0);
+
+  ol.startContents();
+
+  ol.startTextBlock();
+  ol.parseText(lne ? lne->intro() : theTranslator->trStructListDescription());
+  ol.endTextBlock();
+
+  // ---------------
+  // Linear struct index for Latex/RTF
+  // ---------------
+  ol.pushGeneratorState();
+  ol.disable(OutputGenerator::Html);
+  Doxygen::indexList->disable();
+
+  writeAnnotatedClassList(ol, ClassDef::Struct);
+
+  Doxygen::indexList->enable();
+  ol.popGeneratorState();
+
+  // ---------------
+  // Hierarchical struct index for HTML
+  // ---------------
+  ol.pushGeneratorState();
+  ol.disableAllBut(OutputGenerator::Html);
+
+  {
+    if (addToIndex)
+    {
+      Doxygen::indexList->addContentsItem(TRUE,title,0,"annotatedstructs",0,TRUE,TRUE);
+      Doxygen::indexList->incContentsDepth();
+    }
+    FTVHelp* ftv = new FTVHelp(FALSE);
+    writeNamespaceTree(Doxygen::namespaceSDict,ftv,TRUE,TRUE,addToIndex,ClassDef::Struct);
+    writeClassTree(Doxygen::classSDict,ftv,addToIndex,TRUE,ClassDef::Struct);
+    QGString outStr;
+    FTextStream t(&outStr);
+    ftv->generateTreeViewInline(t);
+    ol.writeString(outStr);
+    delete ftv;
+    if (addToIndex)
+    {
+      Doxygen::indexList->decContentsDepth();
+    }
+  }
+
+  ol.popGeneratorState();
+  // ------
+
+  endFile(ol); // contains ol.endContents()
+  ol.popGeneratorState();
+}
+
+//----------------------------------------------------------------------------
+
+static void writeAnnotatedExceptionIndex(OutputList &ol)
+{
+  //printf("writeAnnotatedExceptionIndex: count=%d printed=%d\n",
+  //    annotatedExceptions,annotatedExceptionsPrinted);
+  if (annotatedExceptions==0) return;
+
+  ol.pushGeneratorState();
+  ol.disable(OutputGenerator::Man);
+  if (annotatedExceptionsPrinted==0)
+  {
+    ol.disable(OutputGenerator::Latex);
+    ol.disable(OutputGenerator::RTF);
+  }
+  LayoutNavEntry *lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::ExceptionList);
+  if (lne==0) lne = LayoutDocManager::instance().rootNavEntry()->find(LayoutNavEntry::Exceptions); // fall back
+  QCString title = lne ? lne->title() : theTranslator->trExceptionList();
+  bool addToIndex = lne==0 || lne->visible();
+
+  startFile(ol,"annotatedexceptions",0,title,HLI_AnnotatedExceptions);
+
+  startTitle(ol,0);
+  ol.parseText(title);
+  endTitle(ol,0,0);
+
+  ol.startContents();
+
+  ol.startTextBlock();
+  ol.parseText(lne ? lne->intro() : theTranslator->trExceptionListDescription());
+  ol.endTextBlock();
+
+  // ---------------
+  // Linear interface index for Latex/RTF
+  // ---------------
+  ol.pushGeneratorState();
+  ol.disable(OutputGenerator::Html);
+  Doxygen::indexList->disable();
+
+  writeAnnotatedClassList(ol, ClassDef::Exception);
+
+  Doxygen::indexList->enable();
+  ol.popGeneratorState();
+
+  // ---------------
+  // Hierarchical interface index for HTML
+  // ---------------
+  ol.pushGeneratorState();
+  ol.disableAllBut(OutputGenerator::Html);
+
+  {
+    if (addToIndex)
+    {
+      Doxygen::indexList->addContentsItem(TRUE,title,0,"annotatedexceptions",0,TRUE,TRUE);
+      Doxygen::indexList->incContentsDepth();
+    }
+    FTVHelp* ftv = new FTVHelp(FALSE);
+    writeNamespaceTree(Doxygen::namespaceSDict,ftv,TRUE,TRUE,addToIndex,ClassDef::Exception);
+    writeClassTree(Doxygen::classSDict,ftv,addToIndex,TRUE,ClassDef::Exception);
     QGString outStr;
     FTextStream t(&outStr);
     ftv->generateTreeViewInline(t);
@@ -2402,6 +3012,16 @@ void addNamespaceMemberNameToIndex(MemberDef *md)
         g_namespaceIndexLetterUsed[NMHL_Typedefs].append(letter,md);
         documentedNamespaceMembers[NMHL_Typedefs]++;
       }
+      else if (md->isSequence())
+      {
+        g_namespaceIndexLetterUsed[NMHL_Sequences].append(letter,md);
+        documentedNamespaceMembers[NMHL_Sequences]++;
+      }
+      else if (md->isDictionary())
+      {
+        g_namespaceIndexLetterUsed[NMHL_Dictionaries].append(letter,md);
+        documentedNamespaceMembers[NMHL_Dictionaries]++;
+      }
       else if (md->isEnumerate())
       {
         g_namespaceIndexLetterUsed[NMHL_Enums].append(letter,md);
@@ -2459,6 +3079,16 @@ void addFileMemberNameToIndex(MemberDef *md)
         g_fileIndexLetterUsed[FMHL_Typedefs].append(letter,md);
         documentedFileMembers[FMHL_Typedefs]++;
       }
+      else if (md->isSequence())
+      {
+        g_fileIndexLetterUsed[FMHL_Sequences].append(letter,md);
+        documentedFileMembers[FMHL_Sequences]++;
+      }
+      else if (md->isDictionary())
+      {
+        g_fileIndexLetterUsed[FMHL_Dictionaries].append(letter,md);
+        documentedFileMembers[FMHL_Dictionaries]++;
+      }
       else if (md->isEnumerate())
       {
         g_fileIndexLetterUsed[FMHL_Enums].append(letter,md);
@@ -2702,6 +3332,7 @@ static const FmhlInfo *getFmhlInfo(int hl)
 {
   static bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
   static bool vhdlOpt    = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
+  static bool sliceOpt   = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
   static FmhlInfo fmhlInfo[] =
   {
     FmhlInfo("globals",     theTranslator->trAll()),
@@ -2709,7 +3340,7 @@ static const FmhlInfo *getFmhlInfo(int hl)
          fortranOpt ? theTranslator->trSubprograms()     :
          vhdlOpt    ? theTranslator->trFunctionAndProc() :
                       theTranslator->trFunctions()),
-    FmhlInfo("globals_vars",theTranslator->trVariables()),
+    FmhlInfo("globals_vars",sliceOpt ? theTranslator->trConstants() : theTranslator->trVariables()),
     FmhlInfo("globals_type",theTranslator->trTypedefs()),
     FmhlInfo("globals_enum",theTranslator->trEnumerations()),
     FmhlInfo("globals_eval",theTranslator->trEnumerationValues()),
@@ -2846,6 +3477,8 @@ static void writeFileMemberIndex(OutputList &ol)
   writeFileMemberIndexFiltered(ol,FMHL_Functions);
   writeFileMemberIndexFiltered(ol,FMHL_Variables);
   writeFileMemberIndexFiltered(ol,FMHL_Typedefs);
+  writeFileMemberIndexFiltered(ol,FMHL_Sequences);
+  writeFileMemberIndexFiltered(ol,FMHL_Dictionaries);
   writeFileMemberIndexFiltered(ol,FMHL_Enums);
   writeFileMemberIndexFiltered(ol,FMHL_EnumValues);
   writeFileMemberIndexFiltered(ol,FMHL_Defines);
@@ -2870,6 +3503,7 @@ static const NmhlInfo *getNmhlInfo(int hl)
 {
   static bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
   static bool vhdlOpt    = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
+  static bool sliceOpt   = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
   static NmhlInfo nmhlInfo[] =
   {
     NmhlInfo("namespacemembers",     theTranslator->trAll()),
@@ -2877,8 +3511,10 @@ static const NmhlInfo *getNmhlInfo(int hl)
         fortranOpt ? theTranslator->trSubprograms()     :
         vhdlOpt    ? theTranslator->trFunctionAndProc() :
                      theTranslator->trFunctions()),
-    NmhlInfo("namespacemembers_vars",theTranslator->trVariables()),
+    NmhlInfo("namespacemembers_vars",sliceOpt ? theTranslator->trConstants() : theTranslator->trVariables()),
     NmhlInfo("namespacemembers_type",theTranslator->trTypedefs()),
+    NmhlInfo("namespacemembers_sequ",theTranslator->trSequences()),
+    NmhlInfo("namespacemembers_dict",theTranslator->trDictionaries()),
     NmhlInfo("namespacemembers_enum",theTranslator->trEnumerations()),
     NmhlInfo("namespacemembers_eval",theTranslator->trEnumerationValues())
   };
@@ -3018,6 +3654,8 @@ static void writeNamespaceMemberIndex(OutputList &ol)
   writeNamespaceMemberIndexFiltered(ol,NMHL_Functions);
   writeNamespaceMemberIndexFiltered(ol,NMHL_Variables);
   writeNamespaceMemberIndexFiltered(ol,NMHL_Typedefs);
+  writeNamespaceMemberIndexFiltered(ol,NMHL_Sequences);
+  writeNamespaceMemberIndexFiltered(ol,NMHL_Dictionaries);
   writeNamespaceMemberIndexFiltered(ol,NMHL_Enums);
   writeNamespaceMemberIndexFiltered(ol,NMHL_EnumValues);
   if (documentedNamespaceMembers[NMHL_All]>0 && addToIndex)
@@ -4044,6 +4682,12 @@ static void writeIndex(OutputList &ol)
       ol.parseText(/*projPrefix+*/(fortranOpt?theTranslator->trModulesIndex():theTranslator->trNamespaceIndex()));
       ol.endIndexSection(isNamespaceIndex);
     }
+    if (hierarchyInterfaces>0)
+    {
+      ol.startIndexSection(isClassHierarchyIndex);
+      ol.parseText(/*projPrefix+*/theTranslator->trHierarchicalIndex());
+      ol.endIndexSection(isClassHierarchyIndex);
+    }
     if (hierarchyClasses>0)
     {
       ol.startIndexSection(isClassHierarchyIndex);
@@ -4054,6 +4698,18 @@ static void writeIndex(OutputList &ol)
           ));
       ol.endIndexSection(isClassHierarchyIndex);
     }
+    if (hierarchyExceptions>0)
+    {
+      ol.startIndexSection(isClassHierarchyIndex);
+      ol.parseText(/*projPrefix+*/theTranslator->trHierarchicalIndex());
+      ol.endIndexSection(isClassHierarchyIndex);
+    }
+    if (annotatedInterfacesPrinted>0)
+    {
+      ol.startIndexSection(isCompoundIndex);
+      ol.parseText(/*projPrefix+*/theTranslator->trInterfaceIndex());
+      ol.endIndexSection(isCompoundIndex);
+    }
     if (annotatedClassesPrinted>0)
     {
       ol.startIndexSection(isCompoundIndex);
@@ -4064,6 +4720,18 @@ static void writeIndex(OutputList &ol)
           ));
       ol.endIndexSection(isCompoundIndex);
     }
+    if (annotatedStructsPrinted>0)
+    {
+      ol.startIndexSection(isCompoundIndex);
+      ol.parseText(/*projPrefix+*/theTranslator->trStructIndex());
+      ol.endIndexSection(isCompoundIndex);
+    }
+    if (annotatedExceptionsPrinted>0)
+    {
+      ol.startIndexSection(isCompoundIndex);
+      ol.parseText(/*projPrefix+*/theTranslator->trExceptionIndex());
+      ol.endIndexSection(isCompoundIndex);
+    }
     if (documentedFiles>0)
     {
       ol.startIndexSection(isFileIndex);
@@ -4085,12 +4753,30 @@ static void writeIndex(OutputList &ol)
     ol.parseText(/*projPrefix+*/(fortranOpt?theTranslator->trModuleDocumentation():theTranslator->trNamespaceDocumentation()));
     ol.endIndexSection(isNamespaceDocumentation);
   }
+  if (annotatedInterfacesPrinted>0)
+  {
+    ol.startIndexSection(isClassDocumentation);
+    ol.parseText(/*projPrefix+*/theTranslator->trInterfaceDocumentation());
+    ol.endIndexSection(isClassDocumentation);
+  }
   if (annotatedClassesPrinted>0)
   {
     ol.startIndexSection(isClassDocumentation);
     ol.parseText(/*projPrefix+*/(fortranOpt?theTranslator->trTypeDocumentation():theTranslator->trClassDocumentation()));
     ol.endIndexSection(isClassDocumentation);
   }
+  if (annotatedStructsPrinted>0)
+  {
+    ol.startIndexSection(isClassDocumentation);
+    ol.parseText(/*projPrefix+*/theTranslator->trStructDocumentation());
+    ol.endIndexSection(isClassDocumentation);
+  }
+  if (annotatedExceptionsPrinted>0)
+  {
+    ol.startIndexSection(isClassDocumentation);
+    ol.parseText(/*projPrefix+*/theTranslator->trExceptionDocumentation());
+    ol.endIndexSection(isClassDocumentation);
+  }
   if (documentedFiles>0)
   {
     ol.startIndexSection(isFileDocumentation);
@@ -4129,6 +4815,7 @@ static QArray<bool> indexWritten;
 
 static void writeIndexHierarchyEntries(OutputList &ol,const QList<LayoutNavEntry> &entries)
 {
+  static bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
   QListIterator<LayoutNavEntry> li(entries);
   LayoutNavEntry *lne;
   for (li.toFirst();(lne=li.current());++li)
@@ -4226,8 +4913,101 @@ static void writeIndexHierarchyEntries(OutputList &ol,const QList<LayoutNavEntry
           }
           break;
         case LayoutNavEntry::ClassMembers:
-          msg("Generating member index...\n");
-          writeClassMemberIndex(ol);
+          if (!sliceOpt)
+          {
+            msg("Generating member index...\n");
+            writeClassMemberIndex(ol);
+          }
+          break;
+        case LayoutNavEntry::Interfaces:
+          if (sliceOpt && annotatedInterfaces>0 && addToIndex)
+          {
+            Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,lne->baseFile(),0);
+            Doxygen::indexList->incContentsDepth();
+            needsClosing=TRUE;
+          }
+          break;
+        case LayoutNavEntry::InterfaceList:
+          if (sliceOpt)
+          {
+            msg("Generating annotated interface index...\n");
+            writeAnnotatedInterfaceIndex(ol);
+          }
+          break;
+        case LayoutNavEntry::InterfaceIndex:
+          if (sliceOpt)
+          {
+            msg("Generating alphabetical interface index...\n");
+            writeAlphabeticalInterfaceIndex(ol);
+          }
+          break;
+        case LayoutNavEntry::InterfaceHierarchy:
+          if (sliceOpt)
+          {
+            msg("Generating hierarchical interface index...\n");
+            writeHierarchicalInterfaceIndex(ol);
+            if (Config_getBool(HAVE_DOT) && Config_getBool(GRAPHICAL_HIERARCHY))
+            {
+              msg("Generating graphical interface hierarchy...\n");
+              writeGraphicalInterfaceHierarchy(ol);
+            }
+          }
+          break;
+        case LayoutNavEntry::Structs:
+          if (sliceOpt && annotatedStructs>0 && addToIndex)
+          {
+            Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,lne->baseFile(),0);
+            Doxygen::indexList->incContentsDepth();
+            needsClosing=TRUE;
+          }
+          break;
+        case LayoutNavEntry::StructList:
+          if (sliceOpt)
+          {
+            msg("Generating annotated struct index...\n");
+            writeAnnotatedStructIndex(ol);
+          }
+          break;
+        case LayoutNavEntry::StructIndex:
+          if (sliceOpt)
+          {
+            msg("Generating alphabetical struct index...\n");
+            writeAlphabeticalStructIndex(ol);
+          }
+          break;
+        case LayoutNavEntry::Exceptions:
+          if (sliceOpt && annotatedExceptions>0 && addToIndex)
+          {
+            Doxygen::indexList->addContentsItem(TRUE,lne->title(),0,lne->baseFile(),0);
+            Doxygen::indexList->incContentsDepth();
+            needsClosing=TRUE;
+          }
+          break;
+        case LayoutNavEntry::ExceptionList:
+          if (sliceOpt)
+          {
+            msg("Generating annotated exception index...\n");
+            writeAnnotatedExceptionIndex(ol);
+          }
+          break;
+        case LayoutNavEntry::ExceptionIndex:
+          if (sliceOpt)
+          {
+            msg("Generating alphabetical exception index...\n");
+            writeAlphabeticalExceptionIndex(ol);
+          }
+          break;
+        case LayoutNavEntry::ExceptionHierarchy:
+          if (sliceOpt)
+          {
+            msg("Generating hierarchical exception index...\n");
+            writeHierarchicalExceptionIndex(ol);
+            if (Config_getBool(HAVE_DOT) && Config_getBool(GRAPHICAL_HIERARCHY))
+            {
+              msg("Generating graphical exception hierarchy...\n");
+              writeGraphicalExceptionHierarchy(ol);
+            }
+          }
           break;
         case LayoutNavEntry::Files:
           {
@@ -4341,26 +5121,38 @@ static bool quickLinkVisible(LayoutNavEntry::Kind kind)
 {
   static bool showFiles = Config_getBool(SHOW_FILES);
   static bool showNamespaces = Config_getBool(SHOW_NAMESPACES);
+  static bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
   switch (kind)
   {
-    case LayoutNavEntry::MainPage:         return TRUE;
-    case LayoutNavEntry::User:             return TRUE;
-    case LayoutNavEntry::UserGroup:        return TRUE;
-    case LayoutNavEntry::Pages:            return indexedPages>0;
-    case LayoutNavEntry::Modules:          return documentedGroups>0;
-    case LayoutNavEntry::Namespaces:       return documentedNamespaces>0 && showNamespaces;
-    case LayoutNavEntry::NamespaceList:    return documentedNamespaces>0 && showNamespaces;
-    case LayoutNavEntry::NamespaceMembers: return documentedNamespaceMembers[NMHL_All]>0;
-    case LayoutNavEntry::Classes:          return annotatedClasses>0;
-    case LayoutNavEntry::ClassList:        return annotatedClasses>0;
-    case LayoutNavEntry::ClassIndex:       return annotatedClasses>0;
-    case LayoutNavEntry::ClassHierarchy:   return hierarchyClasses>0;
-    case LayoutNavEntry::ClassMembers:     return documentedClassMembers[CMHL_All]>0;
-    case LayoutNavEntry::Files:            return documentedHtmlFiles>0 && showFiles;
-    case LayoutNavEntry::FileList:         return documentedHtmlFiles>0 && showFiles;
-    case LayoutNavEntry::FileGlobals:      return documentedFileMembers[FMHL_All]>0;
+    case LayoutNavEntry::MainPage:           return TRUE;
+    case LayoutNavEntry::User:               return TRUE;
+    case LayoutNavEntry::UserGroup:          return TRUE;
+    case LayoutNavEntry::Pages:              return indexedPages>0;
+    case LayoutNavEntry::Modules:            return documentedGroups>0;
+    case LayoutNavEntry::Namespaces:         return documentedNamespaces>0 && showNamespaces;
+    case LayoutNavEntry::NamespaceList:      return documentedNamespaces>0 && showNamespaces;
+    case LayoutNavEntry::NamespaceMembers:   return documentedNamespaceMembers[NMHL_All]>0;
+    case LayoutNavEntry::Classes:            return annotatedClasses>0;
+    case LayoutNavEntry::ClassList:          return annotatedClasses>0;
+    case LayoutNavEntry::ClassIndex:         return annotatedClasses>0;
+    case LayoutNavEntry::ClassHierarchy:     return hierarchyClasses>0;
+    case LayoutNavEntry::ClassMembers:       return documentedClassMembers[CMHL_All]>0 && !sliceOpt;
+    case LayoutNavEntry::Interfaces:         return annotatedInterfaces>0;
+    case LayoutNavEntry::InterfaceList:      return annotatedInterfaces>0;
+    case LayoutNavEntry::InterfaceIndex:     return annotatedInterfaces>0;
+    case LayoutNavEntry::InterfaceHierarchy: return hierarchyInterfaces>0;
+    case LayoutNavEntry::Structs:            return annotatedStructs>0;
+    case LayoutNavEntry::StructList:         return annotatedStructs>0;
+    case LayoutNavEntry::StructIndex:        return annotatedStructs>0;
+    case LayoutNavEntry::Exceptions:         return annotatedExceptions>0;
+    case LayoutNavEntry::ExceptionList:      return annotatedExceptions>0;
+    case LayoutNavEntry::ExceptionIndex:     return annotatedExceptions>0;
+    case LayoutNavEntry::ExceptionHierarchy: return hierarchyExceptions>0;
+    case LayoutNavEntry::Files:              return documentedHtmlFiles>0 && showFiles;
+    case LayoutNavEntry::FileList:           return documentedHtmlFiles>0 && showFiles;
+    case LayoutNavEntry::FileGlobals:        return documentedFileMembers[FMHL_All]>0;
     //case LayoutNavEntry::Dirs:             return documentedDirs>0;
-    case LayoutNavEntry::Examples:         return Doxygen::exampleSDict->count()>0;
+    case LayoutNavEntry::Examples:           return Doxygen::exampleSDict->count()>0;
     case LayoutNavEntry::None:             // should never happen, means not properly initialized
       assert(kind != LayoutNavEntry::None);
       return FALSE;