LayoutParser Class Reference

Collaboration diagram for LayoutParser:

Public Member Functions
	LayoutParser (LayoutDocManager &manager)
void	setDocumentLocator (const XMLLocator *locator)
void	error (const std::string &fileName, int lineNr, const std::string &msg)
void	startElement (const std::string &name, const XMLHandlers::Attributes &attrib)
void	endElement (const std::string &name)
void	startSimpleEntry (LayoutDocEntry::Kind k, const std::string &id, const XMLHandlers::Attributes &attrib)
void	startSectionEntry (LayoutDocEntry::Kind k, const std::string &id, const XMLHandlers::Attributes &attrib, const QCString &title)
void	startMemberDeclEntry (const std::string &id, const XMLHandlers::Attributes &attrib, MemberListType type, const QCString &title, const QCString &subscript)
void	startMemberDefEntry (const std::string &id, const XMLHandlers::Attributes &attrib, MemberListType type, const QCString &title, const QCString &)
void	startLayout (const std::string &, const XMLHandlers::Attributes &attrib)
void	startNavIndex (const std::string &, const XMLHandlers::Attributes &)
void	endNavIndex (const std::string &)
void	startNavEntry (const std::string &, const XMLHandlers::Attributes &attrib)
void	endNavEntry (const std::string &)
void	startTop (const std::string &, const XMLHandlers::Attributes &attrib, LayoutDocManager::LayoutPart part, const QCString &scope, LayoutNavEntry::Kind nav)
void	endTop (const std::string &)
void	startMemberDef (const std::string &id, const XMLHandlers::Attributes &attrib)
void	endMemberDef (const std::string &id)
void	startMemberDecl (const std::string &id, const XMLHandlers::Attributes &attrib)
void	endMemberDecl (const std::string &id)
int	majorVersion () const
int	minorVersion () const

Private Attributes
QCString	m_scope
LayoutDocManager &	m_layoutDocManager
LayoutDocManager::LayoutPart	m_part = LayoutDocManager::Undefined
LayoutNavEntry *	m_rootNav = nullptr
bool	m_invalidEntry = false
bool	m_visible = true
const XMLLocator *	m_locator = nullptr
int	m_majorVersion = 1
int	m_minorVersion = 0

Static Private Attributes
static int	m_userGroupCount =0

Detailed Description

Definition at line 194 of file layout.cpp.

Constructor & Destructor Documentation

LayoutParser()

LayoutParser::LayoutParser ( LayoutDocManager & manager )

inline

Definition at line 197 of file layout.cpp.

: m_layoutDocManager(manager) {}

References m_layoutDocManager.

Member Function Documentation

endElement()

void LayoutParser::endElement

(

const std::string &

name

)

Definition at line 1373 of file layout.cpp.

{
  //printf("endElement [%s]::[%s]\n",qPrint(m_scope),qPrint(name));
  auto it=g_elementHandlers.end();
 
  if (!m_scope.isEmpty() && m_scope.right(name.length()+1)==name+"/")
  { // element ends current scope
    it = g_elementHandlers.find(m_scope.left(m_scope.length()-1).str());
  }
  else // continue with current scope
  {
    it = g_elementHandlers.find(m_scope.str()+name);
  }
  if (it!=g_elementHandlers.end())
  {
    it->second.endCb(*this,it->first+" end"); // added end to id to make it unique
  }
}

References anonymous_namespace{layout.cpp}::g_elementHandlers, and m_scope.

Referenced by LayoutDocManager::init(), and LayoutDocManager::parse().

endMemberDecl()

void LayoutParser::endMemberDecl ( const std::string & id )

inline

Definition at line 681 of file layout.cpp.

    {
      int i=m_scope.findRev("memberdecl/");
      if (i!=-1)
      {
        m_scope=m_scope.left(i);
        bool isVisible = true;
        for (const auto &lde : m_layoutDocManager.docEntries(m_part))
        {
          if (lde->kind() == LayoutDocEntry::MemberDeclStart)
          {
             isVisible = static_cast<const LayoutDocEntrySimple*>(lde.get())->visible();
             break;
          }
        }
        if (m_part!=LayoutDocManager::Undefined)
        {
          m_layoutDocManager.addEntry(m_part,std::make_unique<LayoutDocEntrySimple>(LayoutDocEntry::MemberDeclEnd,id,isVisible));
        }
      }
    }

References m_layoutDocManager, m_part, m_scope, and LayoutDocEntrySimple::visible().

endMemberDef()

void LayoutParser::endMemberDef ( const std::string & id )

inline

Definition at line 648 of file layout.cpp.

    {
      QCString scopeOrg = m_scope;
      int i=m_scope.findRev("memberdef/");
      if (i!=-1)
      {
        m_scope=m_scope.left(i);
        bool isVisible = true;
        for (const auto &lde : m_layoutDocManager.docEntries(m_part))
        {
          if (lde->kind() == LayoutDocEntry::MemberDefStart)
          {
             isVisible = static_cast<const LayoutDocEntrySimple*>(lde.get())->visible();
             break;
          }
        }
        if (m_part!=LayoutDocManager::Undefined)
        {
          m_layoutDocManager.addEntry(m_part,std::make_unique<LayoutDocEntrySimple>(LayoutDocEntry::MemberDefEnd,id,isVisible));
        }
      }
    }

References m_layoutDocManager, m_part, m_scope, and LayoutDocEntrySimple::visible().

endNavEntry()

void LayoutParser::endNavEntry ( const std::string & )

inline

Definition at line 616 of file layout.cpp.

    {
      // set the root back to the parent
      if (m_rootNav && !m_invalidEntry) m_rootNav = m_rootNav->parent();
      m_invalidEntry=FALSE;
    }

References FALSE, m_invalidEntry, and m_rootNav.

endNavIndex()

void LayoutParser::endNavIndex ( const std::string & )

inline

Definition at line 286 of file layout.cpp.

    {
      m_scope="";
      if (m_rootNav && !m_rootNav->find(LayoutNavEntry::MainPage))
      {
        // no MainPage node... add one as the first item of the root node...
        m_rootNav->insertChild(0,std::make_unique<LayoutNavEntry>(m_rootNav,LayoutNavEntry::MainPage, TRUE,
                                                   "index",theTranslator->trMainPage(),""));
      }
    }

References m_rootNav, m_scope, theTranslator, and TRUE.

endTop()

void LayoutParser::endTop ( const std::string & )

inline

Definition at line 632 of file layout.cpp.

    {
      m_scope="";
      m_part = LayoutDocManager::Undefined;
    }

References m_part, and m_scope.

error()

void LayoutParser::error ( const std::string & fileName, int lineNr, const std::string & msg )

inline

Definition at line 204 of file layout.cpp.

    {
      warn_layout(fileName.c_str(),lineNr,"{}",msg.c_str());
    }

References msg, and warn_layout.

Referenced by LayoutDocManager::init(), and LayoutDocManager::parse().

majorVersion()

int LayoutParser::majorVersion ( ) const

inline

Definition at line 703 of file layout.cpp.

{ return m_majorVersion; }

References m_majorVersion.

Referenced by LayoutDocManager::init(), and LayoutDocManager::parse().

minorVersion()

int LayoutParser::minorVersion ( ) const

inline

Definition at line 704 of file layout.cpp.

{ return m_minorVersion; }

References m_minorVersion.

Referenced by LayoutDocManager::init(), and LayoutDocManager::parse().

setDocumentLocator()

void LayoutParser::setDocumentLocator ( const XMLLocator * locator )

inline

Definition at line 200 of file layout.cpp.

    {
      m_locator = locator;
    }

References m_locator.

Referenced by LayoutDocManager::init(), and LayoutDocManager::parse().

startElement()

void LayoutParser::startElement	(	const std::string &	name,
		const XMLHandlers::Attributes &	attrib )

Definition at line 1357 of file layout.cpp.

{
  //printf("startElement [%s]::[%s]\n",qPrint(m_scope),qPrint(name));
  auto it = g_elementHandlers.find(m_scope.str()+name);
  if (it!=g_elementHandlers.end())
  {
    it->second.startCb(*this,it->first,attrib);
  }
  else
  {
    std::string fileName = m_locator->fileName();
    warn_layout(fileName.c_str(),m_locator->lineNr(),"Unexpected start tag '{}' found in scope='{}'!",
        name,m_scope);
  }
}

References anonymous_namespace{layout.cpp}::g_elementHandlers, m_locator, m_scope, and warn_layout.

Referenced by LayoutDocManager::init(), and LayoutDocManager::parse().

startLayout()

void LayoutParser::startLayout ( const std::string & , const XMLHandlers::Attributes & attrib )

inline

Definition at line 266 of file layout.cpp.

    {
      // extract and store version number
      QCString version = XMLHandlers::value(attrib,"version");
      static const reg::Ex re(R"((\d+)\.(\d+))");
      reg::Match match;
      if (reg::match(version.view(),match,re))
      {
        m_majorVersion = atoi(match[1].str().c_str());
        m_minorVersion = atoi(match[2].str().c_str());
        //printf("layout version %d.%d\n",m_versionMajor,m_versionMinor);
      }
    }

References m_majorVersion, m_minorVersion, reg::match(), XMLHandlers::value(), and version().

startMemberDecl()

void LayoutParser::startMemberDecl ( const std::string & id, const XMLHandlers::Attributes & attrib )

inline

Definition at line 671 of file layout.cpp.

    {
      m_scope+="memberdecl/";
      bool isVisible = m_visible && elemIsVisible(attrib);
      if (m_part!=LayoutDocManager::Undefined)
      {
        m_layoutDocManager.addEntry(m_part,std::make_unique<LayoutDocEntrySimple>(LayoutDocEntry::MemberDeclStart,id,isVisible));
      }
    }

References elemIsVisible(), m_layoutDocManager, m_part, m_scope, and m_visible.

startMemberDeclEntry()

void LayoutParser::startMemberDeclEntry ( const std::string & id, const XMLHandlers::Attributes & attrib, MemberListType type, const QCString & title, const QCString & subscript )

inline

Definition at line 239 of file layout.cpp.

    {
      QCString userTitle     = XMLHandlers::value(attrib,"title");
      QCString userSubscript = XMLHandlers::value(attrib,"subtitle");
      if (userTitle.isEmpty())     userTitle     = title;
      if (userSubscript.isEmpty()) userSubscript = subscript;
      bool isVisible = m_visible && elemIsVisible(attrib);
      if (m_part!=LayoutDocManager::Undefined)
      {
        m_layoutDocManager.addEntry(m_part,std::make_unique<LayoutDocEntryMemberDecl>(type,id,userTitle,userSubscript,isVisible));
      }
    }

References elemIsVisible(), QCString::isEmpty(), m_layoutDocManager, m_part, m_visible, and XMLHandlers::value().

startMemberDef()

void LayoutParser::startMemberDef ( const std::string & id, const XMLHandlers::Attributes & attrib )

inline

Definition at line 638 of file layout.cpp.

    {
      m_scope+="memberdef/";
      bool isVisible = m_visible && elemIsVisible(attrib);
      if (m_part!=LayoutDocManager::Undefined)
      {
        m_layoutDocManager.addEntry(m_part,std::make_unique<LayoutDocEntrySimple>(LayoutDocEntry::MemberDefStart,id,isVisible));
      }
    }

References elemIsVisible(), m_layoutDocManager, m_part, m_scope, and m_visible.

startMemberDefEntry()

void LayoutParser::startMemberDefEntry ( const std::string & id, const XMLHandlers::Attributes & attrib, MemberListType type, const QCString & title, const QCString &  )

inline

Definition at line 253 of file layout.cpp.

    {
      QCString userTitle = XMLHandlers::value(attrib,"title");
      if (userTitle.isEmpty()) userTitle = title;
      //printf("memberdef: %s\n",qPrint(userTitle));
      bool isVisible = m_visible && elemIsVisible(attrib);
      if (m_part!=LayoutDocManager::Undefined)
      {
        m_layoutDocManager.addEntry(m_part,std::make_unique<LayoutDocEntryMemberDef>(type,id,userTitle,isVisible));
      }
    }

References elemIsVisible(), QCString::isEmpty(), m_layoutDocManager, m_part, m_visible, and XMLHandlers::value().

startNavEntry()

void LayoutParser::startNavEntry ( const std::string & , const XMLHandlers::Attributes & attrib )

inline

Definition at line 297 of file layout.cpp.

    {
      bool javaOpt    = Config_getBool(OPTIMIZE_OUTPUT_JAVA);
      bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
      bool vhdlOpt    = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
      bool sliceOpt   = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
      bool hasGraphicalHierarchy = Config_getBool(HAVE_DOT) &&
                                          Config_getBool(GRAPHICAL_HIERARCHY);
      bool extractAll = Config_getBool(EXTRACT_ALL);
      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 intro;            // introduction text to be put on the index page
        QCString baseFile;         // base name of the file containing the index page
      } mapping[] =
      {
        { "mainpage",
          LayoutNavEntry::MainPage,
          theTranslator->trMainPage(),
          QCString(),
          QCString(),
          "index"
        },
        { "pages",
          LayoutNavEntry::Pages,
          theTranslator->trRelatedPages(),
          QCString(),
          theTranslator->trRelatedPagesDescription(),
          "pages"
        },
        { "topics",
          LayoutNavEntry::Topics,
          theTranslator->trTopics(),
          QCString(),
          theTranslator->trTopicListDescription(),
          "topics"
        },
        { "modules",
          LayoutNavEntry::Modules,
          theTranslator->trModules(),
          theTranslator->trModulesList(),
          theTranslator->trModulesDescription(),
          "modules"
        },
        { "modulelist",
          LayoutNavEntry::ModuleList,
          theTranslator->trModulesList(),
          QCString(),
          theTranslator->trModulesListDescription(extractAll),
          "modules"
        },
        { "modulemembers",
          LayoutNavEntry::ModuleMembers,
          theTranslator->trModulesMembers(),
          QCString(),
          theTranslator->trModulesMemberDescription(extractAll),
          "modulemembers"
        },
        { "namespaces",
          LayoutNavEntry::Namespaces,
          javaOpt || vhdlOpt   ? theTranslator->trPackages() : fortranOpt || sliceOpt ? theTranslator->trModules() : theTranslator->trNamespaces(),
          javaOpt || vhdlOpt   ? theTranslator->trPackageList() : fortranOpt || sliceOpt ? theTranslator->trModulesList() : theTranslator->trNamespaceList(),
          javaOpt || vhdlOpt   ? theTranslator->trPackageListDescription() : fortranOpt || sliceOpt ? theTranslator->trModulesListDescription(extractAll) : theTranslator->trNamespaceListDescription(extractAll),
          "namespaces"
        },
        { "namespacelist",
          LayoutNavEntry::NamespaceList,
          javaOpt || vhdlOpt   ? theTranslator->trPackageList() : fortranOpt || sliceOpt ? theTranslator->trModulesList() : theTranslator->trNamespaceList(),
          QCString(),
          javaOpt || vhdlOpt   ? theTranslator->trPackageListDescription() : fortranOpt || sliceOpt ? theTranslator->trModulesListDescription(extractAll) : theTranslator->trNamespaceListDescription(extractAll),
          "namespaces"
        },
        { "namespacemembers",
          LayoutNavEntry::NamespaceMembers,
          javaOpt || vhdlOpt   ? theTranslator->trPackageMembers() : fortranOpt || sliceOpt ? theTranslator->trModulesMembers() : theTranslator->trNamespaceMembers(),
          QCString(),
          fortranOpt || sliceOpt ? theTranslator->trModulesMemberDescription(extractAll) : theTranslator->trNamespaceMemberDescription(extractAll),
          "namespacemembers"
        },
        { "concepts",
          LayoutNavEntry::Concepts,
          theTranslator->trConcept(true,false),
          theTranslator->trConceptList(),
          theTranslator->trConceptListDescription(extractAll),
          "concepts"
        },
        { "classindex",
          LayoutNavEntry::ClassIndex,
          fortranOpt ? theTranslator->trCompoundIndexFortran() : vhdlOpt ? theTranslator->trDesignUnitIndex() : theTranslator->trCompoundIndex(),
          QCString(),
          QCString(),
          "classes"
        },
        { "classes",
          LayoutNavEntry::Classes,
          fortranOpt ? theTranslator->trDataTypes() : vhdlOpt ? theTranslator->trDesignUnits() : theTranslator->trClasses(),
          theTranslator->trCompoundList(),
          fortranOpt ? theTranslator->trCompoundListDescriptionFortran() : vhdlOpt ? theTranslator->trDesignUnitListDescription() : theTranslator->trCompoundListDescription(),
          "annotated"
        },
        { "classlist",
          LayoutNavEntry::ClassList,
          fortranOpt ? theTranslator->trCompoundListFortran() : vhdlOpt ? theTranslator->trDesignUnitList() : theTranslator->trCompoundList(),
          QCString(),
          fortranOpt ? theTranslator->trCompoundListDescriptionFortran() : vhdlOpt ? theTranslator->trDesignUnitListDescription() : theTranslator->trCompoundListDescription(),
          "annotated"
        },
        { "hierarchy",
          LayoutNavEntry::ClassHierarchy,
          vhdlOpt    ? theTranslator->trDesignUnitHierarchy() : theTranslator->trClassHierarchy(),
          QCString(),
          theTranslator->trClassHierarchyDescription(),
          hasGraphicalHierarchy ? "inherits" : "hierarchy"
        },
        { "classmembers",
          LayoutNavEntry::ClassMembers,
          fortranOpt ? theTranslator->trCompoundMembersFortran() : vhdlOpt ? theTranslator->trDesignUnitMembers() : theTranslator->trCompoundMembers(),
          QCString(),
          fortranOpt ? theTranslator->trCompoundMembersDescriptionFortran(extractAll) : theTranslator->trCompoundMembersDescription(extractAll),
          "functions"
        },
        { "interfaceindex",
          LayoutNavEntry::InterfaceIndex,
          theTranslator->trInterfaceIndex(),
          QCString(),
          QCString(),
          "interfaces"
        },
        { "interfaces",
          LayoutNavEntry::Interfaces,
          theTranslator->trSliceInterfaces(),
          theTranslator->trInterfaceList(),
          theTranslator->trInterfaceListDescription(),
          "annotatedinterfaces"
        },
        { "interfacelist",
          LayoutNavEntry::InterfaceList,
          theTranslator->trInterfaceList(),
          QCString(),
          theTranslator->trInterfaceListDescription(),
          "annotatedinterfaces"
        },
        { "interfacehierarchy",
          LayoutNavEntry::InterfaceHierarchy,
          theTranslator->trInterfaceHierarchy(),
          QCString(),
          theTranslator->trInterfaceHierarchyDescription(),
          hasGraphicalHierarchy ? "interfaceinherits" : "interfacehierarchy"
        },
        { "structindex",
          LayoutNavEntry::StructIndex,
          theTranslator->trStructIndex(),
          QCString(),
          QCString(),
          "structs"
        },
        { "structs",
          LayoutNavEntry::Structs,
          theTranslator->trStructs(),
          theTranslator->trStructList(),
          theTranslator->trStructListDescription(),
          "annotatedstructs"
        },
        { "structlist",
          LayoutNavEntry::StructList,
          theTranslator->trStructList(),
          QCString(),
          theTranslator->trStructListDescription(),
          "annotatedstructs"
        },
        { "exceptionindex",
          LayoutNavEntry::ExceptionIndex,
          theTranslator->trExceptionIndex(),
          QCString(),
          QCString(),
          "exceptions"
        },
        { "exceptions",
          LayoutNavEntry::Exceptions,
          theTranslator->trExceptions(),
          theTranslator->trExceptionList(),
          theTranslator->trExceptionListDescription(),
          "annotatedexceptions"
        },
        { "exceptionlist",
          LayoutNavEntry::ExceptionList,
          theTranslator->trExceptionList(),
          QCString(),
          theTranslator->trExceptionListDescription(),
          "annotatedexceptions"
        },
        { "exceptionhierarchy",
          LayoutNavEntry::ExceptionHierarchy,
          theTranslator->trExceptionHierarchy(),
          QCString(),
          theTranslator->trExceptionHierarchyDescription(),
          hasGraphicalHierarchy ? "exceptioninherits" : "exceptionhierarchy"
        },
        { "files",
          LayoutNavEntry::Files,
          theTranslator->trFile(TRUE,FALSE),
          theTranslator->trFileList(),
          theTranslator->trFileListDescription(extractAll),
          "files"
        },
        { "filelist",
          LayoutNavEntry::FileList,
          theTranslator->trFileList(),
          QCString(),
          theTranslator->trFileListDescription(extractAll),
          "files"
        },
        { "globals",
          LayoutNavEntry::FileGlobals,
          theTranslator->trFileMembers(),
          QCString(),
          theTranslator->trFileMembersDescription(extractAll),
          "globals"
        },
        { "examples",
          LayoutNavEntry::Examples,
          theTranslator->trExamples(),
          QCString(),
          theTranslator->trExamplesDescription(),
          "examples"
        },
        { "user",
          LayoutNavEntry::User,
          QCString(),
          QCString(),
          QCString(),
          "user"
        },
        { "usergroup",
          LayoutNavEntry::UserGroup,
          QCString(),
          QCString(),
          QCString(),
          "usergroup"
        },
        { nullptr, // end of list
          static_cast<LayoutNavEntry::Kind>(0),
          QCString(),
          QCString(),
          QCString(),
          QCString()
        }
      };
      // find type in the table
      int i=0;
      QCString type = XMLHandlers::value(attrib,"type");
      while (mapping[i].typeStr)
      {
        if (mapping[i].typeStr==type)
          break;
        i++;
      }
      if (mapping[i].typeStr==nullptr)
      {
        std::string fileName = m_locator->fileName();
        if (type.isEmpty())
        {
          warn_layout(fileName.c_str(),m_locator->lineNr(),"an entry tag within a navindex has no type attribute! Check your layout file!");
        }
        else
        {
          warn_layout(fileName.c_str(),m_locator->lineNr(),"the type '{}' is not supported for the entry tag within a navindex! Check your layout file!",type);
        }
        m_invalidEntry=TRUE;
        return;
      }
      LayoutNavEntry::Kind kind = mapping[i].kind;
      QCString baseFile = mapping[i].baseFile;
      QCString title = XMLHandlers::value(attrib,"title");
      bool isVisible = m_visible && elemIsVisible(attrib);
      if (title.isEmpty()) // use default title
      {
        title = mapping[i].mainName; // use title for main row
        if (m_rootNav!=m_layoutDocManager.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.
        }
      }
      QCString intro = XMLHandlers::value(attrib,"intro");
      if (intro.isEmpty()) // use default intro text
      {
        intro = mapping[i].intro;
      }
      QCString url = XMLHandlers::value(attrib,"url");
      if (mapping[i].kind==LayoutNavEntry::User && !url.isEmpty())
      {
        baseFile=url;
      }
      else if (kind==LayoutNavEntry::UserGroup)
      {
        if (!url.isEmpty())
        {
          if (url == "[none]")
          {
            baseFile = QCString();
          }
          else
          {
            baseFile=url;
          }
        }
        else
        {
          baseFile+=QCString().sprintf("%d",m_userGroupCount++);
        }
      }
      // create new item and make it the new root
      m_rootNav = m_layoutDocManager.createChildNavEntry(m_rootNav,kind,isVisible,baseFile,title,intro);
    }

References Config_getBool, elemIsVisible(), FALSE, QCString::isEmpty(), m_invalidEntry, m_layoutDocManager, m_locator, m_rootNav, m_userGroupCount, m_visible, QCString::sprintf(), theTranslator, TRUE, XMLHandlers::value(), and warn_layout.

startNavIndex()

void LayoutParser::startNavIndex ( const std::string & , const XMLHandlers::Attributes &  )

inline

Definition at line 280 of file layout.cpp.

    {
      m_scope="navindex/";
      m_rootNav = m_layoutDocManager.rootNavEntry();
    }

References m_layoutDocManager, m_rootNav, and m_scope.

startSectionEntry()

void LayoutParser::startSectionEntry ( LayoutDocEntry::Kind k, const std::string & id, const XMLHandlers::Attributes & attrib, const QCString & title )

inline

Definition at line 224 of file layout.cpp.

    {
      bool isVisible = m_visible && elemIsVisible(attrib);
      QCString userTitle = XMLHandlers::value(attrib,"title");
      //printf("startSectionEntry: title='%s' userTitle='%s'\n",
      //    qPrint(title),qPrint(userTitle));
      if (userTitle.isEmpty())  userTitle = title;
      if (m_part!=LayoutDocManager::Undefined)
      {
        m_layoutDocManager.addEntry(m_part,std::make_unique<LayoutDocEntrySection>(k,id,userTitle,isVisible));
      }
    }

References elemIsVisible(), QCString::isEmpty(), m_layoutDocManager, m_part, m_visible, and XMLHandlers::value().

startSimpleEntry()

void LayoutParser::startSimpleEntry ( LayoutDocEntry::Kind k, const std::string & id, const XMLHandlers::Attributes & attrib )

inline

Definition at line 211 of file layout.cpp.

    {
      bool isVisible = m_visible && elemIsVisible(attrib);
      if (m_part!=LayoutDocManager::Undefined)
      {
        auto elem = std::make_unique<LayoutDocEntrySimple>(k,id,isVisible);
        //printf("startSimpleEntry(%s) isVisible=%d visible=%d\n",qPrint(elem->entryToString()),isVisible,elem->visible());
        m_layoutDocManager.addEntry(m_part,std::move(elem));
      }
    }

References elemIsVisible(), m_layoutDocManager, m_part, and m_visible.

startTop()

void LayoutParser::startTop ( const std::string & , const XMLHandlers::Attributes & attrib, LayoutDocManager::LayoutPart part, const QCString & scope, LayoutNavEntry::Kind nav )

inline

Definition at line 623 of file layout.cpp.

    {
      //printf("startTop(scope=%s)\n",qPrint(scope));
      m_scope = scope;
      m_part = part;
      m_visible = elemIsVisible(attrib);
    }

References elemIsVisible(), m_part, m_scope, and m_visible.

Member Data Documentation

m_invalidEntry

bool LayoutParser::m_invalidEntry = false

private

Definition at line 711 of file layout.cpp.

Referenced by endNavEntry(), and startNavEntry().

m_layoutDocManager

LayoutDocManager& LayoutParser::m_layoutDocManager

private

Definition at line 708 of file layout.cpp.

Referenced by endMemberDecl(), endMemberDef(), LayoutParser(), startMemberDecl(), startMemberDeclEntry(), startMemberDef(), startMemberDefEntry(), startNavEntry(), startNavIndex(), startSectionEntry(), and startSimpleEntry().

m_locator

const XMLLocator* LayoutParser::m_locator = nullptr

private

Definition at line 714 of file layout.cpp.

Referenced by setDocumentLocator(), startElement(), and startNavEntry().

m_majorVersion

int LayoutParser::m_majorVersion = 1

private

Definition at line 715 of file layout.cpp.

Referenced by majorVersion(), and startLayout().

m_minorVersion

int LayoutParser::m_minorVersion = 0

private

Definition at line 716 of file layout.cpp.

Referenced by minorVersion(), and startLayout().

m_part

LayoutDocManager::LayoutPart LayoutParser::m_part = LayoutDocManager::Undefined

private

Definition at line 709 of file layout.cpp.

Referenced by endMemberDecl(), endMemberDef(), endTop(), startMemberDecl(), startMemberDeclEntry(), startMemberDef(), startMemberDefEntry(), startSectionEntry(), startSimpleEntry(), and startTop().

m_rootNav

LayoutNavEntry* LayoutParser::m_rootNav = nullptr

private

Definition at line 710 of file layout.cpp.

Referenced by endNavEntry(), endNavIndex(), startNavEntry(), and startNavIndex().

m_scope

QCString LayoutParser::m_scope

private

Definition at line 707 of file layout.cpp.

Referenced by endElement(), endMemberDecl(), endMemberDef(), endNavIndex(), endTop(), startElement(), startMemberDecl(), startMemberDef(), startNavIndex(), and startTop().

m_userGroupCount

int LayoutParser::m_userGroupCount =0

staticprivate

Definition at line 713 of file layout.cpp.

Referenced by startNavEntry().

m_visible

bool LayoutParser::m_visible = true

private

Definition at line 712 of file layout.cpp.

Referenced by startMemberDecl(), startMemberDeclEntry(), startMemberDef(), startMemberDefEntry(), startNavEntry(), startSectionEntry(), startSimpleEntry(), and startTop().

---

The documentation for this class was generated from the following file:

• src/layout.cpp