Release-1.5.6-20080819

1 files changed, 1121 insertions, 0 deletions

diff --git a/src/layout.cpp b/src/layout.cpp
new file mode 100644
index 0000000..3a9949c
--- /dev/null
+++ b/src/layout.cpp
@@ -0,0 +1,1121 @@
+/******************************************************************************
+ *
+ * 
+ *
+ *
+ * Copyright (C) 1997-2008 by Dimitri van Heesch.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation under the terms of the GNU General Public License is hereby 
+ * granted. No representations are made about the suitability of this software 
+ * for any purpose. It is provided "as is" without express or implied warranty.
+ * See the GNU General Public License for more details.
+ *
+ * Documents produced by Doxygen are derivative works derived from the
+ * input used in their production; they are not affected by this license.
+ *
+ */
+
+#include "layout.h"
+#include "message.h"
+#include "language.h"
+#include "vhdldocgen.h"
+#include "util.h"
+
+#include <qxml.h>
+#include <qfile.h>
+#include <qstring.h>
+#include <qfileinfo.h>
+#include <qtextstream.h>
+
+static const char layout_default[] =
+#include "layout_default.h"
+;
+
+//---------------------------------------------------------------------------------
+
+LayoutNavEntry *LayoutNavEntry::find(LayoutNavEntry::Kind kind) const
+{
+  LayoutNavEntry *result=0;
+  QListIterator<LayoutNavEntry> li(m_children);
+  LayoutNavEntry *entry;
+  for (li.toFirst();(entry=li.current());++li)
+  {
+    // depth first search, needed to find the entry furthest from the 
+    // root in case an entry is in the tree twice
+    result = entry->find(kind);
+    if (result) return result;
+    if (entry->kind()==kind)
+    {
+      return entry;
+    }
+  }
+  return result;
+}
+
+//---------------------------------------------------------------------------------
+
+class LayoutParser : public QXmlDefaultHandler
+{
+  private:
+    class StartElementHandler
+    {
+        typedef void (LayoutParser::*Handler)(const QXmlAttributes &attrib); 
+      public:
+        StartElementHandler(LayoutParser *parent, Handler h) 
+          : m_parent(parent), m_handler(h) {}
+        virtual ~StartElementHandler() {}
+        virtual void operator()(const QXmlAttributes &attrib) 
+        { 
+          (m_parent->*m_handler)(attrib); 
+        }
+      protected:
+        StartElementHandler() : m_parent(0), m_handler(0) {}
+      private:
+        LayoutParser *m_parent;
+        Handler m_handler;
+    };
+
+    class StartElementHandlerKind : public StartElementHandler
+    {
+        typedef void (LayoutParser::*Handler)(LayoutDocEntry::Kind kind,
+                                              const QXmlAttributes &attrib); 
+      public:
+        StartElementHandlerKind(LayoutParser *parent, LayoutDocEntry::Kind k,Handler h) 
+          : m_parent(parent), m_kind(k), m_handler(h) {}
+        void operator()(const QXmlAttributes &attrib) 
+        { 
+          (m_parent->*m_handler)(m_kind,attrib); 
+        }
+      private:
+        LayoutParser *m_parent;
+        LayoutDocEntry::Kind m_kind;
+        Handler m_handler;
+    };
+
+    class StartElementHandlerSection : public StartElementHandler
+    {
+        typedef void (LayoutParser::*Handler)(LayoutDocEntry::Kind kind,
+                                              const QXmlAttributes &attrib,
+                                              const QCString &title); 
+      public:
+        StartElementHandlerSection(LayoutParser *parent, LayoutDocEntry::Kind k,Handler h,
+                                const QCString &title) 
+          : m_parent(parent), m_kind(k), m_handler(h), m_title(title) {}
+        void operator()(const QXmlAttributes &attrib) 
+        { 
+          (m_parent->*m_handler)(m_kind,attrib,m_title); 
+        }
+      private:
+        LayoutParser *m_parent;
+        LayoutDocEntry::Kind m_kind;
+        Handler m_handler;
+        QCString m_title;
+    };
+
+    class StartElementHandlerMember : public StartElementHandler
+    {
+        typedef void (LayoutParser::*Handler)(const QXmlAttributes &attrib,
+                                              MemberList::ListType type,
+                                              const QCString &title,
+                                              const QCString &subtitle); 
+      public:
+        StartElementHandlerMember(LayoutParser *parent, 
+                                  Handler h,
+                                  MemberList::ListType type,
+                                  const QCString &tl,
+                                  const QCString &ss = QCString()
+                                 ) 
+          : m_parent(parent), m_handler(h), m_type(type),
+            m_title(tl), m_subscript(ss) {}
+        void operator()(const QXmlAttributes &attrib) 
+        { 
+          (m_parent->*m_handler)(attrib,m_type,m_title,m_subscript); 
+        }
+      private:
+        LayoutParser *m_parent;
+        Handler m_handler;
+        MemberList::ListType m_type;
+        QCString m_title;
+        QCString m_subscript;
+    };
+
+    class StartElementHandlerNavEntry : public StartElementHandler
+    {
+        typedef void (LayoutParser::*Handler)(LayoutNavEntry::Kind kind,
+                                              const QXmlAttributes &attrib,
+                                              const QCString &title); 
+      public:
+        StartElementHandlerNavEntry(LayoutParser *parent,
+                               LayoutNavEntry::Kind kind, 
+                               Handler h,
+                               const QCString &tl
+                              ) 
+          : m_parent(parent), m_kind(kind), m_handler(h), m_title(tl) {}
+        void operator()(const QXmlAttributes &attrib) 
+        { 
+          (m_parent->*m_handler)(m_kind,attrib,m_title); 
+        }
+      private:
+        LayoutParser *m_parent;
+        LayoutNavEntry::Kind m_kind;
+        Handler m_handler;
+        QCString m_title;
+    };
+
+    class EndElementHandler
+    {
+        typedef void (LayoutParser::*Handler)(); 
+      public:
+        EndElementHandler(LayoutParser *parent, Handler h) : m_parent(parent), m_handler(h) {}
+        void operator()() { (m_parent->*m_handler)(); }
+      private:
+        LayoutParser *m_parent;
+        Handler m_handler;
+    };
+
+
+  public:
+    static LayoutParser &instance()
+    {
+      static LayoutParser *theInstance = new LayoutParser;
+      return *theInstance;
+    }
+    void init()
+    {
+      m_sHandler.setAutoDelete(TRUE);
+      m_eHandler.setAutoDelete(TRUE);
+      m_part = -1; // invalid
+      m_rootNav = 0;
+
+      bool fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN");
+      bool vhdlOpt    = Config_getBool("OPTIMIZE_OUTPUT_VHDL");  
+      bool javaOpt    = Config_getBool("OPTIMIZE_OUTPUT_JAVA");
+
+      // start & end handlers
+      m_sHandler.insert("doxygenlayout", 
+          new StartElementHandler(this,&LayoutParser::startLayout));
+      m_eHandler.insert("doxygenlayout", 
+          new EndElementHandler(this,&LayoutParser::endLayout));
+
+      // class layout handlers
+      m_sHandler.insert("navindex", 
+          new StartElementHandler(this,&LayoutParser::startNavIndex));
+      m_sHandler.insert("navindex/tab", 
+          new StartElementHandler(this,&LayoutParser::startNavEntry));
+      m_eHandler.insert("navindex/tab", 
+          new EndElementHandler(this,&LayoutParser::endNavEntry));
+      m_eHandler.insert("navindex", 
+          new EndElementHandler(this,&LayoutParser::endNavIndex));
+
+      // class layout handlers
+      m_sHandler.insert("class", 
+          new StartElementHandler(this,&LayoutParser::startClass));
+      m_sHandler.insert("class/briefdescription", 
+          new StartElementHandlerKind(this,LayoutDocEntry::BriefDesc,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("class/detaileddescription", 
+          new StartElementHandlerSection(this,LayoutDocEntry::DetailedDesc,&LayoutParser::startSectionEntry,
+                                         theTranslator->trDetailedDescription()));
+      m_sHandler.insert("class/authorsection", 
+          new StartElementHandlerKind(this,LayoutDocEntry::AuthorSection,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("class/includes", 
+          new StartElementHandlerKind(this,LayoutDocEntry::ClassIncludes,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("class/inheritancegraph", 
+          new StartElementHandlerKind(this,LayoutDocEntry::ClassInheritanceGraph,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("class/collaborationgraph", 
+          new StartElementHandlerKind(this,LayoutDocEntry::ClassCollaborationGraph,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("class/allmemberslink", 
+          new StartElementHandlerKind(this,LayoutDocEntry::ClassAllMembersLink,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("class/usedfiles", 
+          new StartElementHandlerKind(this,LayoutDocEntry::ClassUsedFiles,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("class/memberdecl", 
+          new StartElementHandler(this,&LayoutParser::startMemberDecl));
+      m_sHandler.insert("class/memberdecl/membergroups", 
+          new StartElementHandlerKind(this,LayoutDocEntry::MemberGroups,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("class/memberdecl/nestedclasses", 
+          new StartElementHandlerSection(this,LayoutDocEntry::ClassNestedClasses,&LayoutParser::startSectionEntry,
+                                         vhdlOpt ? VhdlDocGen::trVhdlType(VhdlDocGen::ARCHITECTURE,FALSE) :
+                                         fortranOpt ? theTranslator->trDataTypes() :
+                                         theTranslator->trCompounds() 
+                                         ));
+      m_sHandler.insert("class/memberdecl/publictypes", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::pubTypes,theTranslator->trPublicTypes()));
+      m_sHandler.insert("class/memberdecl/publicslots", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::pubSlots,theTranslator->trPublicSlots())); 
+      m_sHandler.insert("class/memberdecl/signals", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::signals,theTranslator->trSignals())); 
+      m_sHandler.insert("class/memberdecl/publicmethods", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::pubMethods,theTranslator->trPublicMembers())); 
+      m_sHandler.insert("class/memberdecl/publicstaticmethods", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::pubStaticMethods,theTranslator->trStaticPublicMembers())); 
+      m_sHandler.insert("class/memberdecl/publicattributes", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::pubAttribs,theTranslator->trPublicAttribs())); 
+      m_sHandler.insert("class/memberdecl/publicstaticattributes", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::pubStaticAttribs,theTranslator->trStaticPublicAttribs())); 
+      m_sHandler.insert("class/memberdecl/protectedtypes", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::proTypes,theTranslator->trProtectedTypes())); 
+      m_sHandler.insert("class/memberdecl/protectedslots", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::proSlots,theTranslator->trProtectedSlots())); 
+      m_sHandler.insert("class/memberdecl/protectedmethods", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::proMethods,theTranslator->trProtectedMembers())); 
+      m_sHandler.insert("class/memberdecl/protectedstaticmethods", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::proStaticMethods,theTranslator->trStaticProtectedMembers()));
+      m_sHandler.insert("class/memberdecl/protectedattributes", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::proAttribs,theTranslator->trProtectedAttribs())); 
+      m_sHandler.insert("class/memberdecl/protectedstaticattributes", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::proStaticAttribs,theTranslator->trStaticProtectedAttribs())); 
+      m_sHandler.insert("class/memberdecl/packagetypes", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::pacTypes,theTranslator->trPackageTypes())); 
+      m_sHandler.insert("class/memberdecl/packagemethods", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::pacMethods,theTranslator->trPackageMembers())); 
+      m_sHandler.insert("class/memberdecl/packagestaticmethods", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::pacStaticMethods,theTranslator->trStaticPackageMembers())); 
+      m_sHandler.insert("class/memberdecl/packageattributes", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::pacAttribs,theTranslator->trPackageAttribs())); 
+      m_sHandler.insert("class/memberdecl/packagestaticattributes", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::pacStaticAttribs,theTranslator->trStaticPackageAttribs())); 
+      m_sHandler.insert("class/memberdecl/properties", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::properties,theTranslator->trProperties())); 
+      m_sHandler.insert("class/memberdecl/events", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::events,theTranslator->trEvents())); 
+      m_sHandler.insert("class/memberdecl/privatetypes", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::priTypes,theTranslator->trPrivateTypes())); 
+      m_sHandler.insert("class/memberdecl/privateslots", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::priSlots,theTranslator->trPrivateSlots())); 
+      m_sHandler.insert("class/memberdecl/privatemethods", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::priMethods,theTranslator->trPrivateMembers())); 
+      m_sHandler.insert("class/memberdecl/privatestaticmethods", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::priStaticMethods,theTranslator->trStaticPrivateMembers())); 
+      m_sHandler.insert("class/memberdecl/privateattributes", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::priAttribs,theTranslator->trPrivateAttribs())); 
+      m_sHandler.insert("class/memberdecl/privatestaticattributes", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::priStaticAttribs,theTranslator->trStaticPrivateAttribs())); 
+      m_sHandler.insert("class/memberdecl/friends", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::friends,theTranslator->trFriends()));
+      m_sHandler.insert("class/memberdecl/related", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::related,theTranslator->trRelatedFunctions(),
+                                        theTranslator->trRelatedSubscript())); 
+      m_eHandler.insert("class/memberdecl", 
+          new EndElementHandler(this,&LayoutParser::endMemberDecl));
+      m_sHandler.insert("class/memberdef", 
+          new StartElementHandler(this,&LayoutParser::startMemberDef));
+      m_sHandler.insert("class/memberdef/typedefs", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::typedefMembers,theTranslator->trMemberTypedefDocumentation()));
+      m_sHandler.insert("class/memberdef/enums", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::enumMembers,theTranslator->trMemberEnumerationDocumentation()));
+      m_sHandler.insert("class/memberdef/constructors", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::constructors,theTranslator->trConstructorDocumentation()));
+      m_sHandler.insert("class/memberdef/functions", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::functionMembers,
+                                        fortranOpt ?
+                                        theTranslator->trMemberFunctionDocumentationFortran() :
+                                        theTranslator->trMemberFunctionDocumentation()));
+      m_sHandler.insert("class/memberdef/related", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::relatedMembers,theTranslator->trRelatedFunctionDocumentation()));
+      m_sHandler.insert("class/memberdef/variables", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::variableMembers,theTranslator->trMemberDataDocumentation()));
+      m_sHandler.insert("class/memberdef/properties", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::propertyMembers,theTranslator->trPropertyDocumentation()));
+      m_sHandler.insert("class/memberdef/events", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::eventMembers,theTranslator->trEventDocumentation()));
+      m_eHandler.insert("class/memberdef", 
+          new EndElementHandler(this,&LayoutParser::endMemberDef));
+      m_eHandler.insert("class", 
+          new EndElementHandler(this,&LayoutParser::endClass));
+
+
+      // namespace layout handlers
+      m_sHandler.insert("namespace", 
+          new StartElementHandler(this,&LayoutParser::startNamespace));
+      m_sHandler.insert("namespace/briefdescription", 
+          new StartElementHandlerKind(this,LayoutDocEntry::BriefDesc,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("namespace/detaileddescription", 
+          new StartElementHandlerSection(this,LayoutDocEntry::DetailedDesc,&LayoutParser::startSectionEntry,
+                                         theTranslator->trDetailedDescription()));
+      m_sHandler.insert("namespace/authorsection", 
+          new StartElementHandlerKind(this,LayoutDocEntry::AuthorSection,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("namespace/memberdecl", 
+          new StartElementHandler(this,&LayoutParser::startMemberDecl));
+      m_sHandler.insert("namespace/memberdecl/nestednamespaces", 
+          new StartElementHandlerSection(this,LayoutDocEntry::NamespaceNestedNamespaces,&LayoutParser::startSectionEntry,
+                                         javaOpt ? theTranslator->trPackages() :
+                                         fortranOpt ? theTranslator->trModules() :
+                                         theTranslator->trNamespaces()
+                                         ));
+      m_sHandler.insert("namespace/memberdecl/classes", 
+          new StartElementHandlerSection(this,LayoutDocEntry::NamespaceClasses,&LayoutParser::startSectionEntry,
+                                         vhdlOpt ? VhdlDocGen::trVhdlType(VhdlDocGen::ARCHITECTURE,FALSE) :
+                                         fortranOpt ? theTranslator->trDataTypes() :
+                                         theTranslator->trCompounds() 
+                                         ));
+      m_sHandler.insert("namespace/memberdecl/membergroups", 
+          new StartElementHandlerKind(this,LayoutDocEntry::MemberGroups,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("namespace/memberdecl/typedefs", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::decTypedefMembers,theTranslator->trTypedefs()));
+      m_sHandler.insert("namespace/memberdecl/enums", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::decEnumMembers,theTranslator->trEnumerations()));
+      m_sHandler.insert("namespace/memberdecl/functions", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::decFuncMembers,
+                                        fortranOpt ? theTranslator->trSubprograms()  : 
+                                        vhdlOpt    ? VhdlDocGen::trFunctionAndProc() :
+                                        theTranslator->trFunctions()));
+      m_sHandler.insert("namespace/memberdecl/variables", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::decVarMembers,theTranslator->trVariables()));
+      m_eHandler.insert("namespace/memberdecl", 
+          new EndElementHandler(this,&LayoutParser::endMemberDecl));
+      m_sHandler.insert("namespace/memberdef", 
+          new StartElementHandler(this,&LayoutParser::startMemberDef));
+      m_sHandler.insert("namespace/memberdef/typedefs", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::docTypedefMembers,theTranslator->trTypedefDocumentation()));
+      m_sHandler.insert("namespace/memberdef/enums", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::docEnumMembers,theTranslator->trEnumerationTypeDocumentation()));
+      m_sHandler.insert("namespace/memberdef/functions", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::docFuncMembers,
+                                        fortranOpt ? 
+                                        theTranslator->trSubprogramDocumentation() :
+                                        theTranslator->trFunctionDocumentation()));
+      m_sHandler.insert("namespace/memberdef/variables", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::docVarMembers,theTranslator->trVariableDocumentation()));
+      m_eHandler.insert("namespace/memberdef", 
+          new EndElementHandler(this,&LayoutParser::endMemberDef));
+      m_eHandler.insert("namespace", 
+          new EndElementHandler(this,&LayoutParser::endNamespace));
+
+      // file layout handlers
+      m_sHandler.insert("file", 
+          new StartElementHandler(this,&LayoutParser::startFile));
+      m_sHandler.insert("file/briefdescription", 
+          new StartElementHandlerKind(this,LayoutDocEntry::BriefDesc,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("file/detaileddescription", 
+          new StartElementHandlerSection(this,LayoutDocEntry::DetailedDesc,&LayoutParser::startSectionEntry,
+                                         theTranslator->trDetailedDescription()));
+      m_sHandler.insert("file/authorsection", 
+          new StartElementHandlerKind(this,LayoutDocEntry::AuthorSection,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("file/includes", 
+          new StartElementHandlerKind(this,LayoutDocEntry::FileIncludes,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("file/includegraph", 
+          new StartElementHandlerKind(this,LayoutDocEntry::FileIncludeGraph,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("file/includedbygraph", 
+          new StartElementHandlerKind(this,LayoutDocEntry::FileIncludedByGraph,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("file/sourcelink", 
+          new StartElementHandlerKind(this,LayoutDocEntry::FileSourceLink,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("file/memberdecl", 
+          new StartElementHandler(this,&LayoutParser::startMemberDecl));
+      m_sHandler.insert("file/memberdecl/classes", 
+          new StartElementHandlerSection(this,LayoutDocEntry::FileClasses,&LayoutParser::startSectionEntry,
+                                         vhdlOpt ? VhdlDocGen::trVhdlType(VhdlDocGen::ARCHITECTURE,FALSE) :
+                                         fortranOpt ? theTranslator->trDataTypes() :
+                                         theTranslator->trCompounds() 
+                                         ));
+      m_sHandler.insert("file/memberdecl/namespaces", 
+          new StartElementHandlerSection(this,LayoutDocEntry::FileNamespaces,&LayoutParser::startSectionEntry,
+                                         javaOpt ? theTranslator->trPackages() :
+                                         fortranOpt ? theTranslator->trModules() :
+                                         theTranslator->trNamespaces()
+                                         ));
+      m_sHandler.insert("file/memberdecl/defines", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::decDefineMembers,theTranslator->trDefines()));
+      m_sHandler.insert("file/memberdecl/typedefs", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::decTypedefMembers,theTranslator->trTypedefs()));
+      m_sHandler.insert("file/memberdecl/enums", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::decEnumMembers,theTranslator->trEnumerations()));
+      m_sHandler.insert("file/memberdecl/functions", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::decFuncMembers,
+                                        fortranOpt ? theTranslator->trSubprograms()  : 
+                                        vhdlOpt    ? VhdlDocGen::trFunctionAndProc() :
+                                        theTranslator->trFunctions())) ;
+      m_sHandler.insert("file/memberdecl/variables", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::decVarMembers,theTranslator->trVariables()));
+
+      m_eHandler.insert("file/memberdecl", 
+          new EndElementHandler(this,&LayoutParser::endMemberDecl));
+      m_sHandler.insert("file/memberdef", 
+          new StartElementHandler(this,&LayoutParser::startMemberDef));
+      m_sHandler.insert("file/memberdef/defines", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::docDefineMembers,theTranslator->trDefineDocumentation()));
+      m_sHandler.insert("file/memberdef/typedefs", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::docTypedefMembers,theTranslator->trTypedefDocumentation()));
+      m_sHandler.insert("file/memberdef/enums", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::docEnumMembers,theTranslator->trEnumerationTypeDocumentation()));
+      m_sHandler.insert("file/memberdef/functions", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::docFuncMembers,theTranslator->trFunctionDocumentation()));
+      m_sHandler.insert("file/memberdef/variables", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::docVarMembers,theTranslator->trVariableDocumentation()));
+      m_eHandler.insert("file/memberdef", 
+          new EndElementHandler(this,&LayoutParser::endMemberDef));
+      m_eHandler.insert("file", 
+          new EndElementHandler(this,&LayoutParser::endFile));
+
+      // group layout handlers
+      m_sHandler.insert("group", 
+          new StartElementHandler(this,&LayoutParser::startGroup));
+      m_sHandler.insert("group/briefdescription", 
+          new StartElementHandlerKind(this,LayoutDocEntry::BriefDesc,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("group/detaileddescription", 
+          new StartElementHandlerSection(this,LayoutDocEntry::DetailedDesc,&LayoutParser::startSectionEntry,
+                                         theTranslator->trDetailedDescription()));
+      m_sHandler.insert("group/authorsection", 
+          new StartElementHandlerKind(this,LayoutDocEntry::AuthorSection,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("group/groupgraph", 
+          new StartElementHandlerKind(this,LayoutDocEntry::GroupGraph,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("group/memberdecl", 
+          new StartElementHandler(this,&LayoutParser::startMemberDecl));
+      m_sHandler.insert("group/memberdecl/classes", 
+          new StartElementHandlerSection(this,LayoutDocEntry::GroupClasses,&LayoutParser::startSectionEntry,
+                                         vhdlOpt ? VhdlDocGen::trVhdlType(VhdlDocGen::ARCHITECTURE,FALSE) :
+                                         fortranOpt ? theTranslator->trDataTypes() :
+                                         theTranslator->trCompounds() 
+                                         ));
+      m_sHandler.insert("group/memberdecl/namespaces", 
+          new StartElementHandlerSection(this,LayoutDocEntry::GroupNamespaces,&LayoutParser::startSectionEntry,
+                                         javaOpt ? theTranslator->trPackages() :
+                                         fortranOpt ? theTranslator->trModules() :
+                                         theTranslator->trNamespaces()
+                                         ));
+      m_sHandler.insert("group/memberdecl/dirs", 
+          new StartElementHandlerSection(this,LayoutDocEntry::GroupDirs,&LayoutParser::startSectionEntry,
+                                         theTranslator->trDirectories()
+                                         ));
+      m_sHandler.insert("group/memberdecl/nestedgroups", 
+          new StartElementHandlerSection(this,LayoutDocEntry::GroupNestedGroups,&LayoutParser::startSectionEntry,
+                                         theTranslator->trModules()
+                                         ));
+      m_sHandler.insert("group/memberdecl/files", 
+          new StartElementHandlerSection(this,LayoutDocEntry::GroupFiles,&LayoutParser::startSectionEntry,
+                                         theTranslator->trFile(TRUE,FALSE)
+                                         ));
+
+      m_sHandler.insert("group/memberdecl/defines", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::decDefineMembers,theTranslator->trDefines()));
+      m_sHandler.insert("group/memberdecl/typedefs", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::decTypedefMembers,theTranslator->trTypedefs()));
+      m_sHandler.insert("group/memberdecl/enums", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::decEnumMembers,theTranslator->trEnumerations()));
+      m_sHandler.insert("group/memberdecl/enumvalues", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::decEnumValMembers,theTranslator->trEnumerationValues()));
+      m_sHandler.insert("group/memberdecl/functions", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::decFuncMembers,
+                                            fortranOpt ? theTranslator->trSubprograms()  : 
+                                            vhdlOpt    ? VhdlDocGen::trFunctionAndProc() :
+                                            theTranslator->trFunctions()));
+      m_sHandler.insert("group/memberdecl/variables", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::decVarMembers,theTranslator->trVariables()));
+      m_sHandler.insert("group/memberdecl/signals", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::decSignalMembers,theTranslator->trSignals()));
+      m_sHandler.insert("group/memberdecl/publicslots", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::decPubSlotMembers,theTranslator->trPublicSlots()));
+      m_sHandler.insert("group/memberdecl/protectedslots", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::decProSlotMembers,theTranslator->trProtectedSlots()));
+      m_sHandler.insert("group/memberdecl/privateslots", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::decPriSlotMembers,theTranslator->trPrivateSlots()));
+      m_sHandler.insert("group/memberdecl/events", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::decEventMembers,theTranslator->trEvents()));
+      m_sHandler.insert("group/memberdecl/properties", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::decPropMembers,theTranslator->trProperties()));
+      m_sHandler.insert("group/memberdecl/friends", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDeclEntry,
+                                        MemberList::decFriendMembers,theTranslator->trFriends()));
+      m_eHandler.insert("group/memberdecl", 
+          new EndElementHandler(this,&LayoutParser::endMemberDecl));
+      m_sHandler.insert("group/memberdef", 
+          new StartElementHandler(this,&LayoutParser::startMemberDef));
+      m_sHandler.insert("group/memberdef/pagedocs", 
+          new StartElementHandlerKind(this,LayoutDocEntry::GroupPageDocs,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("group/memberdef/defines", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::docDefineMembers,theTranslator->trDefineDocumentation()));
+      m_sHandler.insert("group/memberdef/typedefs", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::docTypedefMembers,theTranslator->trTypedefDocumentation()));
+      m_sHandler.insert("group/memberdef/enums", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::docEnumMembers,theTranslator->trEnumerationTypeDocumentation()));
+      m_sHandler.insert("group/memberdef/enumvalues", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::docEnumValMembers,theTranslator->trEnumerationValueDocumentation()));
+      m_sHandler.insert("group/memberdef/functions", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::docFuncMembers,
+                                        fortranOpt?
+                                        theTranslator->trSubprogramDocumentation():
+                                        theTranslator->trFunctionDocumentation()));
+      m_sHandler.insert("group/memberdef/variables", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::docVarMembers,theTranslator->trVariableDocumentation()));
+      m_sHandler.insert("group/memberdef/signals", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::docSignalMembers,theTranslator->trSignals())); 
+      m_sHandler.insert("group/memberdef/publicslots", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::docPubSlotMembers,theTranslator->trPublicSlots()));
+      m_sHandler.insert("group/memberdef/protectedslots", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::docProSlotMembers,theTranslator->trProtectedSlots()));
+      m_sHandler.insert("group/memberdef/privateslots", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::docPriSlotMembers,theTranslator->trPrivateSlots()));
+      m_sHandler.insert("group/memberdef/events", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::docEventMembers,theTranslator->trEvents()));
+      m_sHandler.insert("group/memberdef/properties", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::docPropMembers,theTranslator->trProperties()));
+      m_sHandler.insert("group/memberdef/friends", 
+          new StartElementHandlerMember(this,&LayoutParser::startMemberDefEntry,
+                                        MemberList::docFriendMembers,theTranslator->trFriends()));
+      m_eHandler.insert("group/memberdef", 
+          new EndElementHandler(this,&LayoutParser::endMemberDef));
+      m_eHandler.insert("group", 
+          new EndElementHandler(this,&LayoutParser::endGroup));
+
+      // directory layout handlers
+      m_sHandler.insert("directory", 
+          new StartElementHandler(this,&LayoutParser::startDirectory));
+      m_sHandler.insert("directory/briefdescription", 
+          new StartElementHandlerKind(this,LayoutDocEntry::BriefDesc,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("directory/detaileddescription", 
+          new StartElementHandlerSection(this,LayoutDocEntry::DetailedDesc,&LayoutParser::startSectionEntry,
+                                         theTranslator->trDetailedDescription()));
+      m_sHandler.insert("directory/directorygraph", 
+          new StartElementHandlerKind(this,LayoutDocEntry::DirGraph,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("directory/memberdecl", 
+          new StartElementHandler(this,&LayoutParser::startMemberDecl));
+      m_sHandler.insert("directory/memberdecl/dirs", 
+          new StartElementHandlerKind(this,LayoutDocEntry::DirSubDirs,&LayoutParser::startSimpleEntry));
+      m_sHandler.insert("directory/memberdecl/files", 
+          new StartElementHandlerKind(this,LayoutDocEntry::DirFiles,&LayoutParser::startSimpleEntry));
+      m_eHandler.insert("directory/memberdecl", 
+          new EndElementHandler(this,&LayoutParser::endMemberDecl));
+      m_eHandler.insert("directory", 
+          new EndElementHandler(this,&LayoutParser::endDirectory));
+    }
+
+    void startSimpleEntry(LayoutDocEntry::Kind k,const QXmlAttributes &attrib)
+    {
+      QCString visible = convertToQCString(attrib.value("visible"));
+      bool isVisible = visible.isEmpty() || (visible!="no" && visible!="0");
+      if (m_part!=-1 && isVisible)
+      {
+        LayoutDocManager::instance().addEntry((LayoutDocManager::LayoutPart)m_part,
+                                              new LayoutDocEntrySimple(k));
+      }
+    }
+
+    void startSectionEntry(LayoutDocEntry::Kind k,const QXmlAttributes &attrib,
+                           const QCString &title)
+    {
+      QCString visible = convertToQCString(attrib.value("visible"));
+      bool isVisible = visible.isEmpty() || (visible!="no" && visible!="0");
+      QCString userTitle = convertToQCString(attrib.value("title"));
+      //printf("startSectionEntry: title='%s' userTitle='%s'\n",
+      //    title.data(),userTitle.data());
+      if (userTitle.isEmpty())  userTitle = title;
+      if (m_part!=-1 && isVisible)
+      {
+        LayoutDocManager::instance().addEntry((LayoutDocManager::LayoutPart)m_part,
+                                              new LayoutDocEntrySection(k,userTitle));
+      }
+    }
+
+
+    void startMemberDeclEntry(const QXmlAttributes &attrib,MemberList::ListType type,
+                              const QCString &title,const QCString &subscript)
+    {
+      //QCString visible = convertToQCString(attrib.value("visible"));
+      //bool isVisible = visible.isEmpty() || (visible!="no" && visible!="0");
+      QCString userTitle     = convertToQCString(attrib.value("title"));
+      QCString userSubscript = convertToQCString(attrib.value("subtitle"));
+      if (userTitle.isEmpty())     userTitle     = title;
+      if (userSubscript.isEmpty()) userSubscript = subscript;
+      //printf("memberdecl: %s\n",userTitle.data());
+      if (m_part!=-1 /*&& isVisible*/)
+      {
+        LayoutDocManager::instance().addEntry((LayoutDocManager::LayoutPart)m_part,
+                                              new LayoutDocEntryMemberDecl(type,userTitle,userSubscript));
+      }
+    }
+
+    void startMemberDefEntry(const QXmlAttributes &attrib,MemberList::ListType type,
+                             const QCString &title,const QCString &)
+    {
+      //QCString visible = convertToQCString(attrib.value("visible"));
+      //bool isVisible = visible.isEmpty() || (visible!="no" && visible!="0");
+      QCString userTitle = convertToQCString(attrib.value("title"));
+      if (userTitle.isEmpty()) userTitle = title;
+      //printf("memberdef: %s\n",userTitle.data());
+      if (m_part!=-1 /*&& isVisible*/)
+      {
+        LayoutDocManager::instance().addEntry((LayoutDocManager::LayoutPart)m_part,
+                                              new LayoutDocEntryMemberDef(type,userTitle));
+      }
+    }
+
+    void startLayout(const QXmlAttributes &)
+    {
+    }
+
+    void endLayout()
+    {
+    }
+
+    void startNavIndex(const QXmlAttributes &)
+    {
+      m_scope="navindex/";
+      m_rootNav = LayoutDocManager::instance().rootNavEntry();
+      m_rootNav->clear();
+    }
+
+    void endNavIndex()
+    {
+      m_scope="";
+      if (!m_rootNav->find(LayoutNavEntry::MainPage))
+      {
+        // no MainPage node... add one the first item of the root node...
+        new LayoutNavEntry(m_rootNav,LayoutNavEntry::MainPage, TRUE, usingTreeIndex() ? "main" : "index",theTranslator->trMainPage(),TRUE);
+      }
+    }
+
+    void startNavEntry(const QXmlAttributes &attrib)
+    {
+      bool javaOpt    = Config_getBool("OPTIMIZE_OUTPUT_JAVA");
+      bool fortranOpt = Config_getBool("OPTIMIZE_FOR_FORTRAN");
+      bool vhdlOpt    = Config_getBool("OPTIMIZE_OUTPUT_VHDL");  
+      static struct NavEntryMap
+      {
+        const char *typeStr;       // type attribute name in the XML file
+        LayoutNavEntry::Kind kind; // corresponding enum name
+        QCString mainName;         // default title for an item if it has children
+        QCString subName;          // optional name for an item if it is rendered as a child
+        QCString baseFile;         // base name of the file containing the index page
+      } mapping[] =
+      {
+        { "mainpage",         LayoutNavEntry::MainPage,         theTranslator->trMainPage(),     QCString(), usingTreeIndex() ? "main" : "index" },
+        { "pages",            LayoutNavEntry::Pages,            theTranslator->trRelatedPages(), QCString(), "pages"  },
+        { "modules",          LayoutNavEntry::Modules,          theTranslator->trModules(),      QCString(), "modules" },
+        { "namespaces",       LayoutNavEntry::Namespaces,       javaOpt    ? theTranslator->trPackages() : 
+                                                                fortranOpt ? theTranslator->trModules() : 
+                                                                theTranslator->trNamespaces(),        
+                                                                javaOpt    ? theTranslator->trPackages() :
+                                                                fortranOpt ? theTranslator->trModulesList() :
+                                                                theTranslator->trNamespaceList(), "namespaces" },
+        { "namespacemembers", LayoutNavEntry::NamespaceMembers, javaOpt    ? theTranslator->trPackageMembers() :
+                                                                fortranOpt ? theTranslator->trModulesMembers() :
+                                                                theTranslator->trNamespaceMembers(), QCString(), "namespacemembers" },
+        { "classindex",       LayoutNavEntry::Classes,          fortranOpt ? theTranslator->trDataTypes() :
+                                                                vhdlOpt    ? VhdlDocGen::trDesignUnits() :
+                                                                theTranslator->trCompoundIndex(),
+                                                                QCString(), "classes" },
+        { "classes",          LayoutNavEntry::ClassAnnotated,   fortranOpt ? theTranslator->trCompoundListFortran() :
+                                                                vhdlOpt    ? VhdlDocGen::trDesignUnitList() :
+                                                                theTranslator->trClasses(), 
+                                                                theTranslator->trCompoundList(), "annotated" },
+        { "hierarchy",        LayoutNavEntry::ClassHierarchy,   vhdlOpt    ? VhdlDocGen::trDesignUnitHierarchy() :
+                                                                theTranslator->trClassHierarchy(), QCString(), "hierarchy" },
+        { "classmembers",     LayoutNavEntry::ClassMembers,     fortranOpt ? theTranslator->trCompoundMembersFortran() :
+                                                                vhdlOpt    ? VhdlDocGen::trDesignUnitMembers() :
+                                                                theTranslator->trCompoundMembers(), QCString(), "functions" },
+        { "files",            LayoutNavEntry::Files,            theTranslator->trFile(TRUE,FALSE), 
+                                                                theTranslator->trFileList(), "files" },
+        { "globals",          LayoutNavEntry::FileGlobals,      theTranslator->trFileMembers(), QCString(), "globals" },
+        { "dirs",             LayoutNavEntry::Dirs,             theTranslator->trDirectories(), QCString(), "dirs" },
+        { "examples",         LayoutNavEntry::Examples,         theTranslator->trExamples(), QCString(), "examples" },
+        { 0,                 (LayoutNavEntry::Kind)0,           QCString(), QCString(), QCString() }
+      };
+      LayoutNavEntry::Kind kind;
+      // find type in the table
+      int i=0;
+      QString type = attrib.value("type");
+      while (mapping[i].typeStr)
+      {
+        if (mapping[i].typeStr==type)
+        {
+          kind = mapping[i].kind;
+          break;
+        }
+        i++;
+      }
+      if (mapping[i].typeStr==0) 
+      {
+        if (type.isEmpty())
+        {
+          err("Warning: an entry tag within a navindex has no type attribute! Check your layout file!\n");
+        }
+        else
+        {
+          err("Warning: the type '%s' is not supported for the entry tag within a navindex! Check your layout file!\n");
+        }
+        return;
+      }
+      QCString baseFile = mapping[i].baseFile;
+      QCString title = convertToQCString(attrib.value("title"));
+      QCString visible = convertToQCString(attrib.value("visible"));
+      bool isVisible = visible.isEmpty() || (visible!="no" && visible!="0");
+      if (title.isEmpty()) // use default title
+      { 
+        title = mapping[i].mainName; // use title for main row
+        if (m_rootNav!=LayoutDocManager::instance().rootNavEntry() && !mapping[i].subName.isEmpty())
+        {
+          title = mapping[i].subName; // if this is a child of another row, use the subName if available
+                                      // this is mainly done to get compatible naming with older versions.
+        }
+      }
+      // create new item and make it the new root
+      m_rootNav = new LayoutNavEntry(m_rootNav,kind,kind==LayoutNavEntry::MainPage?TRUE:isVisible,baseFile,title);
+    }
+
+    void endNavEntry()
+    {
+      // set the root back to the parent
+      m_rootNav = m_rootNav->parent();
+    }
+
+    void startClass(const QXmlAttributes &)
+    {
+      LayoutDocManager::instance().clear(LayoutDocManager::Class);
+      m_scope="class/";
+      m_part = (int)LayoutDocManager::Class;
+    }
+
+    void endClass()
+    {
+      m_scope="";
+      m_part = -1;
+    }
+
+    void startNamespace(const QXmlAttributes &)
+    {
+      LayoutDocManager::instance().clear(LayoutDocManager::Namespace);
+      m_scope="namespace/";
+      m_part = (int)LayoutDocManager::Namespace;
+    }
+
+    void endNamespace()
+    {
+      m_scope="";
+      m_part = -1;
+    }
+
+    void startFile(const QXmlAttributes &)
+    {
+      LayoutDocManager::instance().clear(LayoutDocManager::File);
+      m_scope="file/";
+      m_part = (int)LayoutDocManager::File;
+    }
+
+    void endFile()
+    {
+      m_scope="";
+      m_part = -1;
+    }
+
+    void startGroup(const QXmlAttributes &)
+    {
+      LayoutDocManager::instance().clear(LayoutDocManager::Group);
+      m_scope="group/";
+      m_part = (int)LayoutDocManager::Group;
+    }
+
+    void endGroup()
+    {
+      m_scope="";
+      m_part = -1;
+    }
+
+    void startDirectory(const QXmlAttributes &)
+    {
+      LayoutDocManager::instance().clear(LayoutDocManager::Directory);
+      m_scope="directory/";
+      m_part = (int)LayoutDocManager::Directory;
+    }
+
+    void endDirectory()
+    {
+      m_scope="";
+      m_part = -1;
+    }
+
+    void startMemberDef(const QXmlAttributes &)
+    {
+      m_scope+="memberdef/";
+      if (m_part!=-1)
+      {
+        LayoutDocManager::instance().addEntry((LayoutDocManager::LayoutPart)m_part,
+                                              new LayoutDocEntrySimple(LayoutDocEntry::MemberDefStart));
+      }
+    }
+
+    void endMemberDef()
+    {
+      int i=m_scope.findRev("memberdef/");
+      if (i!=-1)
+      {
+        m_scope=m_scope.left(i);
+        if (m_part!=-1)
+        {
+          LayoutDocManager::instance().addEntry((LayoutDocManager::LayoutPart)m_part,
+                                              new LayoutDocEntrySimple(LayoutDocEntry::MemberDefEnd));
+        }
+      }
+    }
+
+    void startMemberDecl(const QXmlAttributes &)
+    {
+      m_scope+="memberdecl/";
+      if (m_part!=-1)
+      {
+        LayoutDocManager::instance().addEntry((LayoutDocManager::LayoutPart)m_part,
+                                              new LayoutDocEntrySimple(LayoutDocEntry::MemberDeclStart));
+      }
+    }
+
+    void endMemberDecl()
+    {
+      int i=m_scope.findRev("memberdecl/");
+      if (i!=-1)
+      {
+        m_scope=m_scope.left(i);
+        if (m_part!=-1)
+        {
+          LayoutDocManager::instance().addEntry((LayoutDocManager::LayoutPart)m_part,
+                                              new LayoutDocEntrySimple(LayoutDocEntry::MemberDeclEnd));
+        }
+      }
+    }
+
+    // reimplemented from QXmlDefaultHandler
+    bool startElement( const QString&, const QString&, 
+                       const QString& name, const QXmlAttributes& attrib )
+    {
+      //printf("startElement [%s]::[%s]\n",m_scope.data(),name.data());
+      StartElementHandler *handler = m_sHandler[m_scope+name];
+      if (handler)
+      {
+        (*handler)(attrib);
+      }
+      else
+      {
+        err("Warning: Unexpected start tag `%s' found in scope='%s'!\n",
+            name.data(),m_scope.data());
+      }
+      return TRUE;
+    }
+    bool endElement( const QString&, const QString&, const QString& name )
+    {
+      //printf("endElement [%s]::[%s]\n",m_scope.data(),name.data());
+      EndElementHandler *handler;
+      if (!m_scope.isEmpty() && m_scope.right(name.length()+1)==name+"/")
+      { // element ends current scope
+        handler = m_eHandler[m_scope.left(m_scope.length()-1)];
+      }
+      else // continue with current scope
+      {
+        handler = m_eHandler[m_scope+name];
+      }
+      if (handler)
+      {
+        (*handler)();
+      }
+      return TRUE;
+    }
+    bool startDocument()
+    {
+      return TRUE;
+    }
+
+  private:
+    LayoutParser() : m_sHandler(163), m_eHandler(17) { }
+
+    QDict<StartElementHandler> m_sHandler;
+    QDict<EndElementHandler>   m_eHandler;
+    QString m_scope;
+    int m_part;
+    LayoutNavEntry *m_rootNav;
+};
+
+//---------------------------------------------------------------------------------
+
+class LayoutErrorHandler : public QXmlErrorHandler
+{
+  public:
+    bool warning( const QXmlParseException &exception )
+    {
+      err("Warning at line %d column %d: %s\n",
+          exception.lineNumber(),exception.columnNumber(),
+          exception.message().data());
+      return FALSE;
+    }
+    bool error( const QXmlParseException &exception )
+    {
+      err("Error at line %d column %d: %s\n",
+          exception.lineNumber(),exception.columnNumber(),
+          exception.message().data());
+      return FALSE;
+    }
+    bool fatalError( const QXmlParseException &exception )
+    {
+      err("Fatal error at line %d column %d: %s\n",
+          exception.lineNumber(),exception.columnNumber(),
+          exception.message().data());
+      return FALSE;
+    }
+    QString errorString() { return ""; }
+
+  private:
+    QString errorMsg;
+};
+
+//---------------------------------------------------------------------------------
+
+class LayoutDocManager::Private
+{
+  public:
+    QList<LayoutDocEntry> docEntries[LayoutDocManager::NrParts];
+    LayoutNavEntry *rootNav;
+};
+
+LayoutDocManager::LayoutDocManager()
+{
+  d = new Private;
+  int i;
+  for (i=0;i<LayoutDocManager::NrParts;i++)
+  {
+    d->docEntries[i].setAutoDelete(TRUE);
+  }
+  d->rootNav = new LayoutNavEntry;
+  LayoutParser::instance().init();
+}
+
+
+void LayoutDocManager::init()
+{
+  // parse the default layout
+  LayoutErrorHandler errorHandler;
+  QXmlInputSource source;
+  source.setData( layout_default );
+  QXmlSimpleReader reader;
+  reader.setContentHandler( &LayoutParser::instance() );
+  reader.setErrorHandler( &errorHandler );
+  reader.parse( source );
+}
+
+LayoutDocManager::~LayoutDocManager()
+{
+  delete d->rootNav;
+  delete d;
+}
+
+LayoutDocManager & LayoutDocManager::instance()
+{
+  static LayoutDocManager *theInstance = new LayoutDocManager;
+  return *theInstance;
+}
+
+const QList<LayoutDocEntry> &LayoutDocManager::docEntries(LayoutDocManager::LayoutPart part) const
+{
+  return d->docEntries[(int)part];
+}
+
+LayoutNavEntry* LayoutDocManager::rootNavEntry() const
+{
+  return d->rootNav;
+}
+
+void LayoutDocManager::addEntry(LayoutDocManager::LayoutPart p,LayoutDocEntry *e)
+{
+  d->docEntries[(int)p].append(e);
+}
+
+void LayoutDocManager::clear(LayoutDocManager::LayoutPart p)
+{
+  d->docEntries[(int)p].clear();
+}
+
+void LayoutDocManager::parse(QTextStream &t)
+{
+  LayoutErrorHandler errorHandler;
+  QXmlInputSource source( t );
+  QXmlSimpleReader reader;
+  reader.setContentHandler( &LayoutParser::instance() );
+  reader.setErrorHandler( &errorHandler );
+  reader.parse( source );
+}
+
+//---------------------------------------------------------------------------------
+
+void writeDefaultLayoutFile(const char *fileName)
+{
+  QFile f(fileName);
+  if (!f.open(IO_WriteOnly))
+  {
+    err("Failed to open file %s for writing!\n",fileName);
+    return;
+  }
+  QTextStream t(&f);
+  t << layout_default;
+}