This page should always go first if you want frames, else it should not be included at all. There are no options to set.

This is the most complex output Page, creating the pages for each class and namespace/module/package. It walks the whole AST creating pages as it goes using flexible "Parts" and "FormatStrategies".

For each Scope in the AST, the output page has a number of Parts. You can write your own Parts, or change the order, but the usual four are 'Heading', 'Summary', 'Inheritance' and 'Detail'. A Part is responsible for visiting all the nodes in the Scope and formatting the sections for each type of declaration. It also provides methods for referencing other declarations with correct URLs, and things like formatting Types for display (with URLs for any names in the type). Each part has a list of FormatStrategies which it calls in turn for each declaration it processes, to generate the output HTML for that declaration.

The difference between the four Parts is what declarations they process (pass to the formatters) on each page:

You can control the output by changing the FormatStrategies used by each part, writing your own FormatStrategies, or even your own Parts!

The FormatStrategies included with Synopsis are:

The default lists of strategies for each "Part" are:

# Normal HTML config
class HTML (Base.Formatter.HTML):
    # A sub object for ScopePages config
    class ScopePages:
        # Following options go here...

This page creates a single output file with a tree of all packages/modules/namespaces in the AST. Each package/module/namespace is a link to an index file of that package, module or namespace.

See the tree_formatter option for how to control the formatting of the tree.

You can change the types of AST Module node which are included in this tree by creating a "ModuleListing" subobject and setting the option "child_types". For example, the Python parser creates "package" and "module" types, IDL creates "module" types, and C++ creates "namespaces".

The ModuleListing Page creates a link at the top of all pages called "Modules" that is also shown in the top-left frame. You can change this text using the "short_title" option of the ModuleListing subobject.

# Normal HTML config
class HTML (Base.Formatter.HTML):
    # A sub object for ModuleListing config
    class ModuleListing:
        child_types = ['package'] # only show packages
        short_title = 'Packages'  # set the title to match

This page goes hand in hand with ModuleListing, creating a concise listing of the declarations in each package/module/namespace. Each declaration is linked to its documentation, but clicking on another package/module/namespace will also load its index page in this frame if the user has javascript enabled. The declarations are sorted into types and displayed in their sections, just like in ScopePages.

This page creates a single output file with a tree of all source files used to create the AST. Each file links to an index page of declarations in that file.

See the tree_formatter option for how to control the formatting of the tree.

Goes hand in hand with FileListing, creating the concise pages for each file.

If you are using the FileSource Page, a [File Source] link will automatically be included at the top of the page.

If you are using the FileDetails Page, a [File Details] link will automatically be included at the top of the page.

Unlike ModuleIndexer, the declarations are displayed in the order they were in the file, with appropriate indenting for non-global declarations.

Shows details about each file, such as what files it included and a quick list of all the declarations declared in it.

Shows source code for each file that the C++ parser created SXR info for. The actual markup of the source code is done by a C++ module for speed. The stored SXR info is used to hyperlink each identifier in the source code with a link to the documentation for that variable, class, etc, and also provide a hover text of what the identifier is, e.g: "member variable LinkStore::private::buffer_start" or "local variable main". The ability to correctly identify the identifiers is dependent on the C++ parser, which is currently pretty good except for sometimes getting overloaded functions wrong, and not understanding template instantiations too well just yet.

If the FileSource page is used should be included in the list before RawFilePages, since both compete to provide the source code for each file - and you generally want the syntax highlighted version!

Shows source code for each file in the project as unformatted text. See DirBrowse for info on how "files in the project" are found.

Shows directories in the project, where each file links to the source code from FileSource if available, the formatted page from RawFilePages if available, or is not a link if neither is available.

Creates pages with cross-reference information for each declaration. Each declaration will show its parent scope, child declarations (if it's a class or module), references and places it was called from. You can navigate around the XRef documentation, but there are no comments shown so it is more useful as a navigation aide for either the source code or regular ScopePages documentation.

The XRefPages module loads compiled XRef information from a single file given in the xref_file option. The XRef information is originally generated in raw (text) format by the C++ parser. You should use the XRefCompiler Linker operation to compile the xref info.

Creates a single page with all inheritance graphs as embedded images using dot (graphviz) to create the graphs. Classes that have no subclasses or superclasses are not shown for brevity.

Creates a single page with the entire object hierarchy in a tree structure. This page is a text-only alternative to the InheritanceGraph page, but both can be used without problems.

Creates a single page with an index of all class, variable, function/method and namespace/module names. The names are sorted alphabetically.