     [file version-texi2any_api.texi not included]

This manual is for GNU Texinfo texi2any program output adaptation using customization files (version VERSION, UPDATED).

Copyright © 2013, 2022 Free Software Foundation, Inc.

     Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.  A copy of the license is included in the section entitled ``GNU Free Documentation License'' in the Texinfo manual.

texi2any Output Customization
*****************************

Overview
********

     All of this information, with the exception of command-line options and search directories associated with command line options (see Loading Init Files), may become obsolete in a future Texinfo release.  Right now, the ``API'' described in this chapter is immature, and incomplete (translations strings customization API, in particular, is lacking), so we must keep open the possibility of incompatible, possibly major, changes.  Of course we try to avoid incompatible changes, but it is not a promise.

This manual describes how to customize the texi2any HTML output. Although some of the features here can technically be used with other output formats, it's not especially useful to do so, so we'll write the documentation as if HTML were the target format.  Most of the customizations are only available for HTML.

The conversion of Texinfo to HTML is done in two steps.  After reading command-line options and init files, input Texinfo code is parsed into a Texinfo Perl tree and information is gathered on the document structure.  This first step can only be customized to a certain extent, by using the command-line options and setting customization variables.  The Texinfo Perl tree describes a Texinfo document in a structured way which makes it easy to go through the tree and format @-commands and other containers.

The second step is the conversion step done in a converter.  The HTML converter takes a Texinfo Perl tree as input and transforms it to HTML.  The code that is used to go through the tree cannot be customized, but the conversion of tree elements can be fully customized.

Loading Initialization Files and Search Paths
*********************************************

     The Config file related paths and even the use of Config files is not definitive.

You can write so-called initialization files, or init files for short, to modify almost every aspect of output formatting. The program loads init files named Config each time it is run. Those files are looked for in the following directories:

DATADIR/texi2any/
     (where DATADIR is the system data directory specified at compile-time, e.g., /usr/local/share)

SYSCONFDIR/texi2any/
     (likewise specified at compile time, e.g., /usr/local/etc)

~/.texi2any/
     (where ~ is the current user's home directory)

./.texi2any/
     (under the current directory)

./
     (the current directory)

All Config files found are loaded, in the above order.  Thus, ./Config can override entries in, say, /usr/local/share/makeinfo/Config.

However, the most common way to load an initialization file is with the --init-file option, explicitly specifying the file to be loaded.  By default the following directories are searched, in the following order.  Only the first file found is used:

 1. The current directory ./;

 2. ./.texi2any/ under the current directory;

 3. ~/.texi2any/ where ~ is the current user's home directory;

 4. SYSCONFDIR/texi2any/ where SYSCONFDIR is the system configuration directory specified at compile-time, e.g., /usr/local/etc;

 5. DATADIR/texi2any/ Where DATADIR is the system data directory likewise specified at compile time, e.g., /usr/local/share;

 6. ./.texinfo/init/ under the current directory;

 7. ~/.texinfo/init/ under the current home directory;

 8. SYSCONFDIR/texinfo/init/ with SYSCONFDIR as above;

 9. DATADIR/texinfo/init/ with DATADIR as above.

 10. DATADIR/texinfo/ext/ with DATADIR as above.

The DATADIR/texinfo/ext/ directory contains the init files directly loaded from texi2any code.  When loaded from texi2any code directly, init files are only searched for in that directory, being considered as part of the program and not as user customization.  Since the directory is also in the list of directories searched for init files loaded by the --init-file option, those init files can also be loaded as regular user specified init files.

Additional directories may be prepended to the list with the --conf-dir option (see Invoking texi2any (Texinfo)).

Init File Basics
****************

Init files are written in Perl, and by convention have extension .init or .pm.  Several init files are included in the Texinfo distribution, and can serve as a good model for writing your own.  Another example is the Texinfo::Convert::HTML module which implements almost all the Texinfo HTML function described in this manual for the conversion to HTML (The Texinfo::Convert::HTML module also implements the HTML converter which go through the tree and call user defined functions.). In Texinfo::Convert::HTML the API may not be followed strictly for performance reasons, in that case there should always be a API info: comment which shows what the API conformant code should be. The Licenses conditions of the diverse files used as example should be taken into account when reusing code.

Init File Namespace
===================

Initialization file are loaded from the main program in the Texinfo::Config namespace.  This means that the namespace of the main program and the namespace of initialization files are distinct, which minimizes the chance of a name clash.

It is possible to start init files with:

     package Texinfo::Config;

It is not required, but it may help some debugging tools determine in which namespace the code is run.

In the Texinfo::Config namespace, the functions names beginning with texinfo_, GNUT_ and _GNUT_ are reserved.  User defined functions in init files should never begin with those prefixes.

The HTML converter is not available directly in the init files namespace, instead it is passed to functions defined in init files and registered as functions to be called from the converter. See User Defined Functions.

Managing Customization Variables
================================

The basic operations on customization variables are to set and retrieve their values.  New variables can also be added.

The customization variables also valid in the main program out of the HTML converter are handled differently if they are strings or arrays.  The customization variables only relevant for the conversion phase are always set like string variables, in particular array or hash references.

Setting Main Program String Variables
-------------------------------------

To set the value of a string customization variable from an initialization file, use texinfo_set_from_init_file:

 -- Function: texinfo_set_from_init_file ($variable_name, $variable_value)
     $VARIABLE_NAME is a string containing the name of the variable you want to set, and $VARIABLE_VALUE is the value to which you want to set it.  $VARIABLE_VALUE may be undef.

For example,

     texinfo_set_from_init_file('documentlanguage', 'fr');

overrides the @documentlanguage from the document.  It would be overridden by --document-language on the command line. Another example:

     texinfo_set_from_init_file('SPLIT', 'chapter');

overrides the default splitting of the document.  It would be overridden by --split on the command line.

A final example:

     texinfo_set_from_init_file('NO_CSS', 1);

overrides the default value for NO_CSS.  It would be overridden by --set-init-variable NO_CSS=1 on the command line.

Setting the output format cannot be done by setting the customization variable TEXINFO_OUTPUT_FORMAT.  This customization variable sets the output format in the main program, but not from init files as additional code needs to be run.  Instead, the texinfo_set_format_from_init_file function should be used:

 -- Function: texinfo_set_format_from_init_file ($output_format)
     $OUTPUT_FORMAT is the output format; sets the output format, without overriding formats set from the command line.

Any output format can be set, but since only HTML can be customized, the main use of texinfo_set_format_from_init_file is to set the format to html, such that HTML is generated instead of Info in the default case.

For the customization variables associated with @-commands, see Customization Variables for @-Commands (Texinfo).  For the customization variables associated with command line options, see Customization Variables and Options (Texinfo).

Modifying Main Program Array Variables
--------------------------------------

     The main program customization variables associated with arrays are not documented.

Customization variables for the main program associated with an array of values are handled differently. Two functions can be used in init files, texinfo_add_to_option_list to add values to the array and texinfo_remove_from_option_list to remove values from the array associated with the customization variable:

 -- Function: texinfo_add_to_option_list ($variable_name, $variable_values_array_reference)
 -- Function: texinfo_remove_from_option_list ($variable_name, $variable_values_array_reference)
     $VARIABLE_NAME is the name of the variable; the values in the array reference $VARIABLE_VALUES_ARRAY_REFERENCE are added to the list associated with the variable with texinfo_add_to_option_list, and removed with texinfo_remove_from_option_list.

Setting Converter Variables in Main Program
-------------------------------------------

Array and hash references customization variables values relevant in converters only (not in main program) can be set through the main program in init files. These variables cannot be set on the command-line.  They are documented in the customization documentation, not in the main Texinfo manual.  Such arrays or hashes references can be passed through texinfo_set_from_init_file.  For example:

     my @SECTION_BUTTONS =
       (
        \&singular_banner,
        'Back', 'Forward',   'FastBack', 'FastForward',
        'Up', 'Top', 'Contents', 'Index', 'About'
       );

     texinfo_set_from_init_file ('SECTION_BUTTONS', \@SECTION_BUTTONS);

Getting Main Program Variables Values
-------------------------------------

To get the value of a variable, the function is texinfo_get_conf:

 -- Function: texinfo_get_conf ($variable_name)
     $VARIABLE_NAME is the name of the variable; its value (possibly undef) is returned.

For example:

     if (texinfo_get_conf('footnotestyle') eq 'separate') { ... }

Adding Customization Variables
------------------------------

Trying to set a customization variable that is not known as a valid customization variable in texi2any is an error.  It is possible, however, to add new customization variables from init files.  To add a customization variable, the function is texinfo_add_valid_customization_option:

 -- Function: texinfo_add_valid_customization_option ($variable_name)
     $VARIABLE_NAME is added as a valid customization variable name.

The variable value, if set, should also be available in the converters and therefore in the init file functions registered and called from the converters.

Init File Loading Error Reporting
=================================

If an error or a warning should be emitted when loading an init file, before the conversion, use texinfo_register_init_loading_error for an error and texinfo_register_init_loading_warning for a warning.

 -- Function: texinfo_register_init_loading_error ($message)
 -- Function: texinfo_register_init_loading_warning ($message)
     Cause an error message or a warning message based on $MESSAGE to be output, taking into account options related to error reporting such as --force or --no-warn.

Errors or warning emitted from user defined functions should use the converter (see Error Reporting in User Defined Functions).

Simple formatting customization
*******************************

Some change in output formatting can be specified with simple code, not very different from simple textual configuration information.

Init File Expansion Contexts: Normal, Preformatted, Code, String, Math
======================================================================

There are five expansion contexts of interest:

normal context
     Paragraphs, index entries, tables, ...

preformatted context
     When spaces between words are kept.  For example, within the @display (see @display (Texinfo)) and @example environments (see @example (Texinfo)), and in menu comments.  The preformatted regions are usually rendered using <pre> elements in HTML.

code context
     When quotes and minus are kept.  In particular ---, `` and other similar constructs are not converted to dash and quote special characters.  For exampe, in @code or @option commands (see Useful Highlighting (Texinfo)).

math context
     Math (see @math (Texinfo)).  Code or preformatted specifications are often used for math too. In those cases, there is no way to separately specify the formatting in math context.

string context
     When rendering strings without formatting elements, for example in titles.  The string context allows for limited formatting, typically without any element when producing HTML or XML, so the value can be used in an attribute.  XML entities can be used in strings.

It is worth mentioning that in some cases, in particular for file names, plain text can also be used in conversion.  There is no associated context in the converter, so the conversion to plain text is usually performed by converting a Texinfo elements tree outside of the main conversion flow.

Simple Customization for Commands Without Arguments
===================================================

These commands include those whose names are a single nonletter character, such as @@, and those with a normal alphabetic name but whose braces should be empty, such as @TeX{} and @AA{}.

To change the formatting of a command, the functions is texinfo_register_no_arg_command_formatting:

 -- Function: texinfo_register_no_arg_command_formatting ($command_name,
     $context, $text, $html_element, $translated_string)
     $COMMAND_NAME is the @-command name, without the leading @. $CONTEXT is normal, preformatted or string. There is no separate math context, preformatted should be used for math context. See Init File Expansion Contexts.  If $CONTEXT is undef, the normal context is assumed.

     The remaining arguments determine the formatting.  If $TEXT is set, the corresponding text is output when the @-command is formatted.  TEXT can contain HTML elements if needed.  If $HTML_ELEMENT is set, the text is enclosed between the $HTML_ELEMENT element opening and the element closing.  If $TRANSLATED_STRING is set, $TRANSLATED_STRING is used as text and is translated when the document language changes. See Texinfo::Translations METHODS (texi2any_internals).

It is not required to set values for all the contexts.  If preformatted context output is not set, normal context output is used.  If string context output is not set, preformatted context output is used.

For example, if you want &shy; to be output for @- in normal, preformatted (and math) and string context, call

     texinfo_register_no_arg_command_formatting('-', undef, '&shy;');

If you want <small>...</small> to be output for @enddots in normal context and ... to be output in other contexts, call

     texinfo_register_no_arg_command_formatting('enddots',
                                                'normal', '...', 'small');
     texinfo_register_no_arg_command_formatting('enddots',
                                                'preformatted', '...');

If you want error--&gt; to be used for @error in every context, with a translation when the document language changes, call

     texinfo_register_no_arg_command_formatting('error', undef, undef, undef,
                                                'error--&gt;');

     There is no possibility to provide custom translations for selected strings, such that the translated string case cannot actually be used in practice.

Simple Customization for Simple Commands with Braces
====================================================

The formatting of the output produced by ``indicator'' and font commands (e.g., @code, @t), and other simple commands with arguments (e.g., @asis, @clicksequence, @sup, @verb) can be changed with texinfo_register_style_command_formatting:

 -- Function: texinfo_register_style_command_formatting ($command_name,
     $html_element, $in_quotes, $context)
     $COMMAND_NAME is the @-command name, without the leading @. $CONTEXT is normal, preformatted or string. There is no separate math context, preformatted should be used for math context. See Init File Expansion Contexts.  If $CONTEXT is undef, the normal context is assumed.

     If $HTML_ELEMENT is set, the argument is enclosed between the $HTML_ELEMENT element opening and the element closing. $HTML_ELEMENT is always ignored in string context.  If $IN_QUOTES is true, the result is enclosed in quotes associated with customization variables OPEN_QUOTE_SYMBOL and CLOSE_QUOTE_SYMBOL.

     If $HTML_ELEMENT is undefined and $IN_QUOTES is not set, the formatted argument is output as is.

For example, to set @sansserif{argument} to be formatted as <code>ARGUMENT</code> in normal and preformatted context, and as a quoted string in string context, use:

     texinfo_register_style_command_formatting('sansserif', 'code', 0, 'normal');
     texinfo_register_style_command_formatting('sansserif', 'code', 0,
                                               'preformatted');
     texinfo_register_style_command_formatting('sansserif', undef, 1, 'string');

To output the formatted argument of @t as is:

     foreach my $context ('normal', 'example', string') {
       texinfo_register_style_command_formatting ('t', undef,
                                                  undef, $context);
     }

Simple Customization of Accent Commands
=======================================

The formatting of accent commands (@', @ringaccent, @dotless) can be customized with USE_NUMERIC_ENTITY. It is also possible to change how accented commands are converted to named entities.  The accent named entities are obtained by combining a letter to be accented, such as e and a postfix based on the accent command name, for example acute for the acute accent @'.  For example, @'e is converted to the &eacute; named entity in the default case.

The association of accent @-command and named entity postfix and the list of letters that can be prepended can be changed with texinfo_register_accent_command_formatting:

 -- Function: texinfo_register_accent_command_formatting ($accent_command_name, $entity_postfix, $letters)
     $ACCENT_COMMAND_NAME is a Texinfo accent formatting @-command name, $ENTITY_POSTFIX is a string corresponding to the accent command that is postpended to the letter accent argument.  $LETTERS is a string listing the letters that can be combined with the $ENTITY_POSTFIX. If $ENTITY_POSTFIX or $LETTERS is an empty string, numeric entities are used instead of named entities.

For example, with the following code, @dotless{i} should be converted to &inodot;, and @dotless{j} to &jnodot;.  Other letters than i and j in argument of @dotless should not be combined into a named entity with that example.

     texinfo_register_accent_command_formatting('dotless', 'nodot', 'ij');

Simple Customization of Containers
==================================

Texinfo tree elements that are not text container nor directly associated with an @-command can have information set on their formatting.  The first piece of information is whether their contents should be considered in code context (see Init File Expansion Contexts).  The other piece of information is the type of preformatted environment they are, analogous with the @-command names of @example or @display (Note that setting the type of preformatted environment does not make sure that there are preformatted containers used for the formatting of their contents instead of paragraph containers, since this is determined in the very first step of parsing the Texinfo code, which cannot be customized.).

The function used is texinfo_register_type_format_info:

 -- Function: texinfo_register_type_format_info ($type, $code_type, $pre_class_type)
     $TYPE is the type of the container.  If $CODE_TYPE is set, the container contents are assumed to be in code context. See Init File Expansion Contexts. If $PRE_CLASS_TYPE is set, the HTML <pre> elements class attribute are based on $PRE_CLASS_TYPE, if there are such HTML elements output for preformatted content of $TYPE containers.

For example, to set content appearing in-between node links in @menu, which is in the menu_comment container type to be formatted in a code context, with preformatted type menu-between, use:

     texinfo_register_type_format_info('menu_comment', 1, 'menu-between');

See Texinfo::Parser Types of container elements (texi2any_internals), for a description of container types.

Simple Customization of CSS Rules and Imports
=============================================

CSS in HTML output can already be modified with command line options (see HTML CSS (Texinfo)) and customization options such as NO_CSS and INLINE_CSS_STYLE.

Information on static CSS data used in conversion and some control over the CSS output is possible.  The information is about CSS rules lines and CSS import lines obtained from parsing --css-include=FILE files, as described in HTML CSS (Texinfo), and CSS style rules associated with HTML elements and class attributes used in the conversion to HTML.  The CSS style rules selectors are, classically, ELEMENT.CLASS strings with ELEMENT an HTML element and CLASS an attribute class associated to that element.

The function used are css_get_info to get information and css_add_info to modify:

 -- Function: $CONVERTER->css_get_info ($specification, $css_info)
 -- Function: $CONVERTER->css_add_info ($specification, $css_info, $css_style)

     Those functions can only be used on a converter $CONVERTER, from functions registered and called with a converter.  $SPECIFICATION is 'rules' to get information on or set information for CSS rules lines and 'imports' to get information on or set information for CSS import lines. Any other value for $SPECIFICATION corresponds to CSS style rules associated with HTML elements and class attributes selectors.

     With css_get_info, if $SPECIFICATION is set to 'rules' or 'imports', the corresponding arrays are returned.  Otherwise, if $CSS_INFO is undef, a hash reference with all the CSS rules selector as keys and the corresponding rules as values is returned.  If $CSS_INFO is defined, it is considered to be a CSS rule selector and the corresponding CSS style is returned, or undef if not found.

     With css_add_info, $CSS_INFO is an additional entry added to CSS rules lines if $SPECIFICATION is set to 'rules' or an additional entry added to CSS import lines if $SPECIFICATION is set to 'imports'. Otherwise, $CSS_INFO is a CSS rule selector and the associated style rule is set to $CSS_STYLE.

Some examples of use:

     my @all_included_rules = $converter->css_get_info('rules');
     my $all_default_selector_styles = $converter->css_get_info('styles');
     my $titlefont_header_style = $converter->css_get_info('styles',
                                                           'h1.titlefont');

     $converter->css_add_info('styles', 'h1.titlefont', 'text-align:center');
     $converter->css_add_info('imports', "\@import \"special.css\";\n");

Note that the CSS selectors and associated style rules that can be accessed and modified will not necessarily end up in the HTML output. They are output only if the HTML element and class corresponding to a selector is seen in the document. See Customizing CSS.

How to run code during the conversion process is described later (see Init File Calling at Different Stages). The simplest way to use the css_add_info function would be to use a function registered for the structure stage:

     sub my_function_set_some_css {
       my $converter = shift;

       $converter->css_add_info('styles', 'h1.titlefont',
                                'text-align:center');
       # ... more calls to  $converter->css_add_info();
     }

     texinfo_register_handler('structure', \&my_function_set_some_css);

See Customizing CSS for even more control on CSS lines output.

Simple headers customizations
*****************************

Some customization of navigation panels appearing in header and footers in output can be specified with simple code.  To explain how navigation panels are customized, we first describe how the document is organized and which directions are available as the directions is the basis for navigation panel customization.

Output Element Units
====================

We will call the main unit of output documents a document unit, or a Texinfo tree element unit.  An element unit's association with output files is determined by the split options (see Splitting Output (Texinfo)).  This section describes precisely how these output units work, with details for customization.

The output elements are:

Normal document units
     These are normal sections and nodes.  Usually a node is associated with a following sectioning command, while a sectioning command is associated with a previous node; they both together make up the element unit.  Either the node or the sectioning command is considered to be the main element component, depending on the values of the customization variables USE_NODES (see HTML Customization Variables (Texinfo)).

     For example, when generating Info, the nodes are the units; when generating HTML, either case may happen (see Two Paths (Texinfo)).

Top element

     The top element is the highest element unit in the document structure.  If the document has an @top section (see @top Command (Texinfo)), it is the element associated with that section; otherwise, it is the element associated with the document's @node Top (see The Top Node (Texinfo)).  If there is no @node Top, the first element in the document is the top element.

Miscellaneous elements
     The remaining element units are associated with different files if the document is split, and also if MONOLITHIC is not set.  There are four such miscellaneous elements, also called special elements:

      1. Table of contents

      2. Short table of contents, also called Overview

      3. Footnotes page

      4. About page

     More details:

       * The Table of contents should only be formatted if @contents is present in the document.

       * Similarly the Short table of contents should only appear if @shortcontents or @summarycontents is present.

       * The customization variables contents and shortcontents may be set to trigger the output of the respective elements.

       * If CONTENTS_OUTPUT_LOCATION is set to separate_element, the Table of contents and Short table of contents elements are separate (see Contents and Short Table of Contents Customization). Otherwise the Table of contents and Short table of contents elements are directly included within the document, at locations depending on the specific CONTENTS_OUTPUT_LOCATION value.

       * When generating HTML, the Footnotes page should only be present if the footnotes appear on a separate page (see Footnote Styles (Texinfo)).  However, a footnote element is present if the document is not split.

       * The About page shouldn't be present for documents consisting of only one sectioning element, or for monolithic documents without navigation information, or if DO_ABOUT is not set.

It is common not to have anything but normal element units, especially in case of monolithic output.

The main component of elements is sections if USE_NODES is 0; conversely, the main component is nodes if USE_NODES is set.

When sections are the main components of element units, ``isolated'' nodes not directly associated with a sectioning command are associated with the following sectioning command, while sectioning commands without nodes constitute element units.  Conversely, when nodes are the main components of elements, isolated sections not associated with nodes are associated with the previous node, and isolated nodes are element units.

Directions
==========

A variety of data items, called element directions, are associated with element units.  They may be used in the formatting functions, and/or associated with a button (see Simple Navigation Panel Customization).

Each element direction has a name and a reference to the element unit they point to, when such an element exists.  The element is either a global element unit (for example, the first element) or relative to the current element unit (for example, the next element unit).  Such relative elements are determined with respect to the document structure defined by the section structuring commands (@chapter, @unnumbered...) or by the nodes if the node pointers are specified on @node lines or in menus (see Two Paths (Texinfo)).

Here is the list of element units directions:

     An empty button.

Top
     Top element.

About
     About (help) page.

Contents
     Table of contents.

Overview
     Overview: short table of contents.

Footnotes
     Corresponds to the Footnotes element (see Output Element Units).

Index
     The first element unit with @printindex.

This
     The current element unit.

Forward
     Next element unit in reading order.

First
     First element unit in reading order.

Last
     Last element unit in reading order.

Back
     Previous element unit in reading order.

FastForward
     Next chapter element unit.

FastBack
     Beginning of this chapter, or previous chapter if the element is a chapter.

Next
     Next section element unit at the same level.

Prev
     Previous section element unit at the same level.

Up
     Up section.

SectionNext
     Next element unit in section reading order.

SectionPrev
     Previous element unit in section reading order.

SectionUp
     Up in section reading order.

NodeNext
     Next node element unit.

NodeForward
     Next node element unit in node reading order.

NodeBack
     Previous node element unit in node reading order.

NodePrev
     Previous node element unit.

NodeUp
     Up node element unit.

The element directions also have types of information associated, which are in general set dynamically depending on the current element unit, for instance on the element unit whose navigation panel is being formatted:

href
     A string that can be used as an href attribute linking to the element unit corresponding to the direction.

string
     A string representing the direction that can be used in context where only entities are available (attributes). See Init File Expansion Contexts.

text
     A string representing the direction to be used in contexts with HTML elements (preformatted and normal contexts). See Init File Expansion Contexts.

tree
     A Texinfo tree element representing the direction.

target
     A string representing target of the direction, typically used as id attribute in the element unit corresponding to the direction, and in href attribute.

node
     Same as text, but selecting the node associated with the element unit direction in priority.

section
     Same as text, but selecting the sectioning command associated with the element unit direction in priority.

text, tree and string also have a variant with _nonumber prepended, such as text_nonumber without sectioning command number in the representation.

Simple Navigation Panel Customization
=====================================

The navigation panel is the line of links (and labels) that typically appears at the top of each node, so that users can easily get to the next node, the table of contents, and so on.  It can be customized extensively.

The customization variables VERTICAL_HEAD_NAVIGATION, ICONS, HEADERS, HEADER_IN_TABLE, USE_ACCESSKEY, USE_REL_REV and WORDS_IN_PAGE may be used to change the navigation panel formatting. See HTML Customization Variables (Texinfo).

Several arrays and hashes enable even more precise control over the navigation panel buttons and their display.  They can be set as customization variables with texinfo_set_from_init_file. See Setting Main Program String Variables.

The following customization variables arrays determine the buttons present in the various navigation panels:

SECTION_BUTTONS
     Specifies the navigation panel buttons present at the beginning of sectioning elements.  If the output is split at nodes or sections, they are also used at the page footer, and in the case of section navigation being enabled, at the page header.

SECTION_FOOTER_BUTTONS
NODE_FOOTER_BUTTONS
     These arrays specify the navigation panel buttons present in the page footer when the output is split at sections or nodes, respectively.

CHAPTER_BUTTONS
     Specifies the buttons appearing at the page footer if split at chapters, and at the page header if split at chapters and there is no section navigation.

MISC_BUTTONS
     Specifies the buttons appearing at the beginning of special elements and, if the output is split, at the end of such elements.

LINKS_BUTTONS
     Used for <link> elements if they are output in the headers.

TOP_BUTTONS
     Specifies the buttons used in the top element (see Output Element Units).

Each array specifies which buttons are included, and how they are displayed.  Each array element is associated with a button of the navigation panel from left to right.  The meaning of the array element values is the following:

string with an element unit direction
     If icons are not used, the button is a link to the corresponding element whose text is defined by the value associated with the element direction in the hash associated with the BUTTONS_TEXT customization variable, surrounded by [ and ]. If the element direction is  , the [ and ] are omitted.

     If icons are used, the button is an image whose file is determined by the value associated with the element direction in the ACTIVE_ICONS variable hash if the link leads to an element, or in the PASSIVE_ICONS variable hash if there is no element to link to.  If there is a link to the element, the icon links to that element.  The button name and button description are given as HTML attributes to have a textual description of the icon.  The corresponding strings are in the BUTTONS_NAME variable hash for the button name and BUTTONS_GOTO variable hash for a more detailed description.

function reference
     The function is called with one boolean argument, true if the navigation panel should be vertical.  Should return the formatted button text.

scalar reference
     The scalar value is printed.

array reference of length 2
     Here, the first array element should be a an element direction. A link to the element unit associated with the element direction is generated.  The text of the link depends on the second array element.

     reference to a text string
          In that case, the corresponding text is used.

     reference to a function
          The functions is called with two arguments, the converter object and the element direction and should return two scalars, the link href and text and a boolean set if a delimiter is needed after that button.

     text string
          The text string is interpreted as an element direction information type and the corresponding text is used for the link. See Element Direction Information Type.

          For example, if the button array element is

               [ 'Next', 'node' ]

          Then the button will be a link to the next section with text based on the name of the node associated with the next section element unit.

If the customization variable USE_ACCESSKEY is set, the accesskey attribute is used in navigation.  The BUTTONS_ACCESSKEY customization variable hash is then used for the accesskey attributes.

Similarly, if the USE_REL_REV customization variable is set, the rel attribute is used in navigation.  In that case the BUTTONS_REL customization variable hash is used for the rel attribute.

User Defined Functions
**********************

Getting beyond the customization described previously requires writing some functions and registering those functions such that they are called for the conversion. This allows dynamic redefinition of functions used to produce output.

User Defined Functions are Registered
=====================================

User defined functions are always passed as a code reference to a registering function, together with a string describing what the function formats. In the following made up example, my_formatting_function is passed as a function reference \&my_formatting_function to the registering function texinfo_register_command_formatting, with the string specifying the formatting done by the function being format_thing:

     sub my_formatting_function {
       my $arg1 = shift;
       my $arg2 = shift;
       # prepare $formatted_text
       ...
       return $formatted_text;
     }

     texinfo_register_command_formatting ('format_thing', \&my_formatting_function);

As such functions are defined by a reference name associated with a string we will always use the string in function prototypes.  For the function arguments we will use \@array to indicate a reference to an array (a.k.a. list, in Perl terminology), \%hash for a reference to a hash and \&function for a reference on a function.

To illustrate these conventions, here is the prototype for the function associated with format_thing:

 -- Function Reference: $TEXT format_thing ($ARG1, \@ARG2)
     A function reference associated with format_thing has a first argument $ARG1, a second argument a reference to an array \@ARG2, and returns the formatted text $TEXT.

Converter Object and Conversion Functions
=========================================

The first argument of most, if not all user defined function is a converter object.  This object gives access to methods to get information on the conversion context and to methods useful for the conversion, both as an HTML converter and as a generic Texinfo::Convert::Converter (see Texinfo::Convert::Converter Helper methods (texi2any_internals)).  The converter can also be used for error reporting as it is also a Texinfo::Report object (see Texinfo::Report (texi2any_internals)), and for in-document strings translation as it is also a Texinfo::Translations object (see Texinfo::Translations (texi2any_internals)).  See Error Reporting in User Defined Functions on error reporting.

Texinfo Tree Conversion Functions
---------------------------------

One important converter method that can be used in user defined functions is convert_tree that convert a Texinfo tree rooted at any element. There is no reason to use that function often, as the converter already goes through the tree calling reference functions to convert the elements, but it can be interesting in some cases.

 -- Function: $CONVERTED_TEXT = $CONVERTER->convert_tree (\%ELEMENT, $EXPLANATION)
     \%ELEMENT is a Texinfo tree element. $EXPLANATION is optional, it is a string explaining why the function was called, to help in case of debugging.  The function returns \%ELEMENT converted.

convert_tree is suitable when the conversion is in the flow of the Texinfo tree conversion.  Sometime, it is better to ignore the formatting context of the main conversion, for example for the formatting of a caption, or the formatting of footnotes texts.  Another special case is the case of tree elements being converted more than once, even if in the flow of the Texinfo tree conversion, for example if there are multiple @insertcopying in a document.  A last special case arise, with formatting done in advance or out of the main conversion.  This is the case, in practice, for sectioning commands or node commands which may be formatted as directions in navigation panels, menus or indices, may appear more than once in the document and be converted more than once, if language changes, for example.

For such cases, the function is convert_tree_new_formatting_context which sets the context appropriately. convert_tree_new_formatting_context ultimately calls convert_tree.

 -- Function: $CONVERTED_TEXT = $CONVERTER->convert_tree_new_formatting_context
     (\%ELEMENT, $CONTEXT, $MULTIPLE_PASS, $GLOBAL_CONTEXT)
     \%ELEMENT is a Texinfo tree element.  $CONTEXT is an optional string describing the new context to be setup to format out of the main conversion flow.  If not defined, the conversion is done in the main document flow.  $MULTIPLE_PASS is an optional string that marks that the conversion is done more than once.  It should be unique and suitable for inclusion in targets and identifiers.  $GLOBAL_CONTEXT is an optional string that marks that the formatting may be done in advance, and can be redone.

     The function returns \%ELEMENT converted, setting the conversion context according to the arguments.

See Setting the Context for Conversion on how to set a specific context for a Texinfo tree conversion.

Internationalization of Strings Function
----------------------------------------

     There is no possibility to provide custom translations for selected strings, such that only translated strings already recorded in the default code can be used in practice.

The subroutine gdt, from the Texinfo::Translations module is used for translated strings:

 -- Function: $TRANSLATED_TREE = $CONVERTER->gdt ($STRING, \%VARIABLES_HASH)
     $STRING is the string to be translated, \%VARIABLES_HASH is a hash reference holding the variable parts of the translated string.  The result returned is a perl Texinfo tree.

When the string is expanded as Texinfo, and converted to a Texinfo tree in perl, the arguments are substituted; for example, {arg_name} is replaced by the corresponding actual argument, which should be Texinfo perl trees, Texinfo perl tree contents arrays or strings.

In the following example, {date}, {program_homepage} and {program} are the arguments of the string.  Since they are used in @uref, their order in the formatted output depends on the formatting and is not predictable. {date}, {program_homepage} and {program} are substituted after the expansion, which means that they should already be Texinfo perl trees, Texinfo perl tree contents.  A string is turned into a Texinfo text element without type, with the string as text.

       $converter->gdt('Generated @emph{@today{}} using '
        .'@uref{{program_homepage}, @emph{{program}}}.',
           { 'program_homepage' => $converter->get_conf('PACKAGE_URL'),
             'program' => { 'text' => $converter->get_conf('PROGRAM') }}));

In the example, the $converter->get_conf('PACKAGE_URL') string is turned into { 'text' => $converter->get_conf('PACKAGE_URL')  }.

An example of combining conversion with translation:

     $converter->convert_tree($converter->gdt(
            '{explained_string} ({explanation})',
            {'explained_string' => {'type' => '_converted',
                                    'text' => $result},
             'explanation' => {'type' => '_converted',
                               'text' => $explanation_result}}),
                              "convert explained $cmdname");

See Texinfo::Translations (texi2any_internals) for more on Texinfo::Translations. See Internationalization of Document Strings (Texinfo) for an overview.

Error Reporting in User Defined Functions
-----------------------------------------

To report an error or a warning in a user defined function, use the methods of Texinfo::Report through a converter object (see Converter Object and Conversion Functions).

To report a warning or an error not specific of an element conversion, use document_warn or document_error:

 -- Function: $CONVERTER->document_error ($text, $converter)
 -- Function: $CONVERTER->document_warn ($text, $converter)
     Register a document-wide error or warning.  $TEXT is the error or warning message.  The $CONVERTER object should be given as the second argument.

To report a warning or an error in element conversion, use line_warn or line_error
 -- Function: $CONVERTER->line_error ($text, $converter, $location_info)
 -- Function: $CONVERTER->line_warn ($text, $converter, $location_info)
     Register a warning or an error.  $TEXT is the text of the error or warning.  The $CONVERTER object should be given as the second argument.  The optional $ERROR_LOCATION_INFO holds the information on the error or warning location.  The $ERROR_LOCATION_INFO reference on hash may be obtained from Texinfo elements source_info keys.

In general, registering an error does not stop the processing, in particular it does not stop the main conversion of the Texinfo tree. Write initialization files as if the conversion always continued after registering the error.

See Texinfo::Report (texi2any_internals) for more on Texinfo::Report.

Texinfo Tree Elements in User Defined Functions
===============================================

Many user defined functions used for formatting have Texinfo tree elements as arguments.  The user defined code should never modify the tree elements. It is possible to reuse Texinfo tree elements information, but with a copy.  For example, the following is ok:

     my @contents = @{$element->{'contents'}};
     push @contents, {'text' => ' my added text'};
     my $result = $converter->convert_tree({'cmdname' => 'strong',
                                       'contents' => \@contents });

The following is not ok:

     push @{$element->{'contents'}}, {'text' => ' my added text'};

In addition to the elements obtained after parsing a Texinfo document, two elements are added, unit type elements that correspond to the normal document units (see Output Element Units), and special elements with type special_element that correspond to added special elements (see Output Element Units).  These added elements, as well as nodes and sectioning elements hold information on the document structure in the structure element hash (see Texinfo::Structuring METHODS (texi2any_internals)).

Normal tree unit elements have a unit_command key in the extra hash that points to the associated @node or sectioning @-command depending on which of nodes or sectioning commands are the main components of elements. See Output Element Units.

The following keys of the structure hash can be interesting:

associated_unit
     For sectioning and @node @-command elements.  The associated tree unit element.

section_childs
     For sectioning commands elements.  The children of the sectioning element in the sectioning tree.

section_level
     The level of the section, taking into account @raisesections and @lowersections.  Level 0 corresponds to @top or @part and level 1 to @chapter level sectioning commands. See Raise/lower sections (Texinfo).

unit_filename
     For tree unit elements. The associated file name.

unit_next
     For tree unit elements. The next unit element in document order.

unit_prev
     For tree unit elements. The previous unit element in document order.

Detailed information on the tree elements is available in the Texinfo Parser documentation, in particular a list of types and of information in the elements extra hash (see Texinfo::Parser TEXINFO TREE (texi2any_internals)).

Encoding and Decoding File Path Strings
=======================================

Encoding File Path Strings
--------------------------

In general, the strings in the customization functions are character strings.  For most purposes, this is right, and the encoding in output files is taken care of by the converter. Operations on directories and file names, however, such as the creation of a directory or the opening of a file require binary strings.

To encode file names consistently with file name encoding used in the conversion to HTML, there is a function encoded_output_file_name:

 -- Function: ($ENCODED_NAME, $ENCODING) = $CONVERTER->encoded_output_file_name ($CHARACTER_STRING_NAME)
     Encode $CHARACTER_STRING_NAME in the same way as other file name are encoded in the converter, based on DOC_ENCODING_FOR_OUTPUT_FILE_NAME, and LOCALE_OUTPUT_FILE_NAME_ENCODING or on input file encoding (see Other Customization Variables (Texinfo)).  Return the encoded name and the encoding used to encode the name.

There is also a similar function for the input file names encoding, encoded_input_file_name, which uses DOC_ENCODING_FOR_INPUT_FILE_NAME and LOCALE_INPUT_FILE_NAME_ENCODING and is less likely to be useful.

When calling external commands, the command line arguments should also be encoded.  To do similarly with other codes, the customization variable MESSAGE_ENCODING should be used.  Already encoded file names may be used.  For example

     use Encode qw(encode);

     ....

     my ($encoded_file_path, $encoding)
       = $converter->encoded_output_file_name($file_name);

     my $fh = open($encoded_file_path);

     .....

     my $call_start = "command --set '$action' ";
     my $encoding = $converter->get_conf('MESSAGE_ENCODING');
     if (defined($encoding)) {
       $encoded_call_start = encode($encoding, $call_start);
     } else {
       $encoded_call_start = $call_start;
     }
     my $encoded_call = $encoded_call_start . $encoded_file_path;
     my $call = $call_start . $file_name;
     if (system($encoded_call)) {
      $converter->document_error($converter,
          sprintf(__("command did not succeed: %s"),
                 $call));
     }

Decoding File Path Strings
--------------------------

The binary strings that could be accessed correspond to the customization variables strings or arrays INCLUDE_DIRECTORIES, CSS_FILES, MACRO_EXPAND and INTERNAL_LINKS.  If they need to be decoded into character strings, for example to appear in error messages, it is possible to use the COMMAND_LINE_ENCODING customization variable value as encoding name to mimic how the decoding of these strings from the command line is done in the main program and in the converters.  For example:

     my $macro_expand_fname = $self->get_conf('MACRO_EXPAND');
     my $encoding = $self->get_conf('COMMAND_LINE_ENCODING');
     if (defined($encoding)) {
       $macro_expand_fname = Encode::decode($encoding, $macro_expand_fname);
     }

More information on perl and encodings in perlunifaq (https://perldoc.perl.org/perlunifaq).

Setting the Context for Conversion
==================================

Special container types are recognized by the converter and can be used to convert a Texinfo tree in a specific context.  Those types cannot appear in a regular Texinfo tree.  They can be the type directly associated with a text element, or the type of a tree root element.

The types are:

_code
     In this container, the conversion is done in a code context see Init File Expansion Contexts.

_converted
     In this container, the texts are considered to be already formatted. This is more likely to be relevant as the type of a text element.

_string
     In this container, the conversion is done in a string context. See Init File Expansion Contexts.

These contexts are typically used together with converter conversion functions (see Converter Object and Conversion Functions). For example:

     my @contents = @{$element->{'contents'}};
     push @contents, {'text' => ' <code>HTML</code> text ',
                        'type' => '_converted'};
     my $result = $converter->convert_tree({'type' => '_code',
                                       'contents' => \@contents });

There is no context for plain text, but the conversion to plain text can be achieved by using the Texinfo::Text converter (see Texinfo::Convert::Text (texi2any_internals)).  For example, to convert the Texinfo tree element $ELEMENT to plain text:

     my $plaintext = Texinfo::Convert::Text::convert_to_text($element,
       Texinfo::Convert::Text::copy_options_for_convert_text($converter, 1));

Setting and Getting Conversion Customization Variables
======================================================

The customization variables values set during the conversion process may be different from the main program customization variables.  The general rule is that variables set in the main program, in particular from init files, are passed to the converter.  Some variables, however, only appear in the converter. Some variables are also set in the converter based on the main program customization variables.  Finally, some variables should be set or reset during conversion, in particular when converting the tree representing the Texinfo document, when expanding the tree element corresponding to @-commands associated with customization variables.

The functions described here should be used in user defined functions, but should not be used out of functions. Conversly, the similar functions used to set customization variables from init files without a converter should not be used in functions, but should be used out of functions in init files (see Managing Customization Variables).

To get the value of a variable in a converter $converter, the function is get_conf:

 -- Function: $CONVERTER->get_conf ($variable_name)
     $VARIABLE_NAME is the name of the variable; its value in the converter $CONVERTER (possibly undef) is returned.

For example:

     my $footnotestyle = $converter->get_conf('footnotestyle');

To set a variable in a converter $converter, the function is set_conf:

 -- Function: $CONVERTER->set_conf ($variable_name, $variable_value)
     $VARIABLE_NAME is the name of the variable; its value in the converter $CONVERTER is set to $VARIABLE_VALUE.  The $VARIABLE_NAME value will not be overidden if it was set from the command line or from an init file.

For example:

     $converter->set_conf('footnotestyle', 'separate');

Some customization variables, in particular those associated with @-commands, can be reset to the value they had before starting the conversion.  For example, they are reset in order to obtain their value before the conversion. Thet are also reset to the value they had before starting the conversion when their value at the end of the preambule or at the end of the document is needed, but there are no @-commands at those locations in the Texinfo manual. If a value set by set_conf is intended to be found when the customization variable value is reset, set_conf should be called early. For example, when called from a user-defined function called at different stage, it should be called in the setup stage (see Init File Calling at Different Stages).

The values set in converter with set_conf will not override command-line set customization variables, nor variables set early in init files.  This is the expected behaviour, in particular when the values are set from the document. In the rare cases when overriding the customization would be needed, the force_conf functions can be used:

 -- Function: $CONVERTER->force_conf ($variable_name, $variable_value)
     $VARIABLE_NAME is the name of the variable; its value in the converter $CONVERTER is set to $VARIABLE_VALUE, overriding any previous value.

Conversion General Information
==============================

Some general information is available from the converter.

To determine if an output format such as html or tex is expanded (see Conditional Commands (Texinfo)), use is_format_expanded:

 -- Function: $IS_FORMAT_EXPANDED = $CONVERTER->is_format_expanded ($FORMAT)
     Return true if format $FORMAT is expanded, according to command-line and init file information.

The main method to get information from the converter is get_info:

 -- Function: $INFO = $CONVERTER->get_info ($ITEM)
     Return information on $ITEM.

The available information is about:

copying_comment
     Text appearing in @copying with all the Texinfo commands put into comments (see @copying (Texinfo)).

current_filename
     The file name of the current document unit being converted.

destination_directory
     Destination directory for the output files.  It is common to use that string in directory or file paths with functions requiring binary strings.  In that case the character string needs to be encoded.  See Encoding File Path Strings.

document_name
     Base name of the document.  It is common to use that string in in directory or file paths with functions requiring binary strings.  In that case the character string needs to be encoded.  See Encoding File Path Strings.

documentdescription_string
     @documentdescription argument converted in a string context (see @documentdescription (Texinfo)).  See Init File Expansion Contexts.

floats
     Information on floats. Gathered from the Texinfo parsing result. See Texinfo::Parser::floats_information (texi2any_internals).

global_commands
     Global commands information.  Gathered from the Texinfo parsing result. See Texinfo::Parser::global_commands_information (texi2any_internals).

index_entries
     Information on indices taking into account merged indices. See Texinfo::Structuring::merge_indices (texi2any_internals).

index_entries_by_letter
     Index entries sorted by letter. See Texinfo::Structuring::sort_indices (texi2any_internals).

jslicenses
     An hash reference with  categories of javascript used in the document as keys. The corresponding values are also hashes with file names as keys and with array references as values.  The array references contain information on each of the file licences, with content

      1. licence name

      2. license url

      3. file name or source of file

line_break_element
     HTML line break element, based on <br>, also taking into account USE_XML_SYNTAX customization variable value.

non_breaking_space
     Non breaking space, can be &nbsp;, but also a non breaking space character or the corresponding numeric entity based on ENABLE_ENCODING and USE_NUMERIC_ENTITY customization variables values.

paragraph_symbol
     Paragraph symbol, can be &para;, but also the corresponding numeric entity or encoded character based on ENABLE_ENCODING and USE_NUMERIC_ENTITY customization variables values.

title_string

title_tree

simpletitle_tree

simpletitle_command_name
     Some information is deduced from the title commands: simpletitle reflects @settitle vs. @shorttitlepage, and title is constructed by trying all the title-related commands, including @top and @titlefont, in the top element.

     title_tree is a Texinfo tree corresponding to the title, title_string is the result of the conversion in a string context (see Init File Expansion Contexts).  simpletitle_tree is a Texinfo tree corresponding to the simpletitle, and simpletitle_command_name is the @-command name used for the simpletitle, without the leading @.

structuring
     Information on the document structure.  Gathered before the conversion. Two hash keys correspond to interesting information, sectioning_root which points to the top level sectioning command tree element, and sections_list which holds the list of the sectioning commands in the document.

title_titlepage
     The formatted title, possibly based on @titlepage, or on simpletitle_tree and similar information, depending on SHOW_TITLE and USE_TITLEPAGE_FOR_TITLE customization variables in the default case.

See Simple Customization of CSS for an explanation on getting information on CSS.

Customizing Output-Related Names
********************************

It is possible to control both output file names and target identifiers in detail.

User defined functions customizing file names and targets are registered with texinfo_register_file_id_setting_function:

 -- Function: texinfo_register_file_id_setting_function ($customized, \&handler)
     $CUSTOMIZED is a string describing what the function should set.  \&HANDLER should be a reference on the user defined function.  The different functions that can be registered have different arguments and return values.

The different possibilities for the customized information are explained in the next sections.

For example:

     sub my_node_file_name($$$) {
       my ($converter, $element, $filename) = @_;
       # ....
       return $node_file_name
     }

     texinfo_register_file_id_setting_function('node_file_name',
                                               \&my_node_file_name);

Customizing Output File Names
=============================

It is possible to specify the output file names with more control than merely the command line option --output (see Invoking texi2any (Texinfo)). The PREFIX customization variable overrides the base name of the file given by @setfilename or the file name and should not contain any directory components.  To alter intermediate directories, use the SUBDIR customization variable. Finally, the extension may also be overriden by the customization variable EXTENSION.  This variable should be undef if no extension is to be added.

Furthermore, the customization variables TOP_FILE override the output file name for the top element.

Two function references registered with texinfo_register_file_id_setting_function enable further customization.  The first, node_file_name is used to customize the nodes files names.

 -- Function Reference: $NODE_FILE node_file_name ($CONVERTER,
     \%NODE_ELEMENT, $FILE_NAME)
     $CONVERTER is a converter object.  \%NODE_ELEMENT is the Texinfo tree element corresponding to the @node.  $FILE_NAME is the node file name that has been already set.  The function should return the node file name ($NODE_FILE).

The other function reference, tree_unit_file_name, is used to customize the file names associated with each element unit, and the name of the file associated with the special elements (see Output Element Units).

 -- Function Reference: ($FILE, $PATH) tree_unit_file_name ($CONVERTER,
     \%UNIT_ELEMENT, $FILE_NAME, $FILE_PATH)
     $CONVERTER is a converter object.  \%UNIT_ELEMENT is the Texinfo element corresponding to the unit element.  $FILE_NAME is the file name that has been already set.  $FILE_PATH is the file path that has been already set.  $FILE_PATH is undef if the file is relative to the output directory, which is the case if the output is split.  The function should return the file name for the unit element, $FILE, and the file path for the unit element, $PATH, which should be undef if the file path is to be constructed by putting $FILE in the destination directory.

In the user defined functions, the information that a unit element is associated with @top or @node Top or more generally considered to be the Top element may be determined with

     $converter->element_is_tree_unit_top(\%unit_element);

The information on tree elements may be interesting for those functions (see Texinfo Tree Elements in User Defined Functions).  The extra key associated_section of a node element and associated_node of a sectioning command element may also be useful.

Customizing Output Target Names
===============================

Similar to file names, so-called target and id names may be set.  The id is placed where the item is located, while the target is used to construct references to that item.  The id and target are the same.  Functions used to set both targets and file names are also described here.

The following function reference is for target items (nodes, anchors, floats):

 -- Function Reference: $TARGET label_target_name
     ($CONVERTER, \%LABEL_INFO, $DEFAULT_TARGET)
     $CONVERTER is a converter object.  \%LABEL_INFO is a hash reference containing a normalized key with value the normalized node name, a node_content key with value a reference on an array containing the Texinfo tree contents of the command label. $DEFAULT_TARGET is the target that has been already set.  The function should return the target ($TARGET).

The element corresponding to the label can be found with label_command (see Target Commands Links, Texts and Associated Commands):

     my $element;
     $element = $converter->label_command($label_info->{'normalized'})
       if (defined($label_info->{'normalized'}));

For sectioning commands, in addition to the sectioning command target, targets for the sectioning command in table of contents and in short table of contents are needed. The following function reference is for sectioning command related target and file name:

 -- Function Reference: ($TARGET, $TARGET_CONTENTS, $TARGET_SHORTCONTENTS, $FILE)
     sectioning_command_target_name ($CONVERTER, \%SECTION_ELEMENT, $DEFAULT_TARGET,
     $DEFAULT_TARGET_CONTENTS, $DEFAULT_TARGET_SHORTCONTENTS, $FILE_NAME)
     $CONVERTER is a converter object. \%SECTION_ELEMENT is the Texinfo element corresponding to the sectioning command.

     $DEFAULT_TARGET, $DEFAULT_TARGET_CONTENTS and $DEFAULT_TARGET_SHORTCONTENTS are the targets that have been already set for the sectioning element and the sectioning element in table of contents and in short table of contents.  $FILE_NAME is the file name that has been already set.

     The function should return the $TARGET, $TARGET_CONTENTS and $TARGET_SHORTCONTENTS sectioning element target and sectioning element in table of contents and in short table of contents targets, and the file name for the sectioning element ($FILE).

For special element units (see Output Element Units), the function reference is:

 -- Function Reference: ($TARGET, $FILE) special_element_target_file_name
     ($CONVERTER, \%ELEMENT, $DEFAULT_TARGET, $FILE_NAME)
     $CONVERTER is a converter object. \%ELEMENT is the Texinfo element corresponding to the special element unit. $DEFAULT_TARGET is the target that has been already set, and $FILE_NAME is the file name that has been already set. The function should return the $TARGET and $FILE.

Init File Calling at Different Stages
*************************************

Arbitrary user-defined functions may be called during conversion. This could be used, for example, to initialize variables and collect some @-commands text, and doing clean-up after the Texinfo tree conversion.

There are four places for user defined functions:

setup
     Called right after completing main program customization information with converter specific customization information, but before anything else is done, including collecting the output files names and registering the customization variables pre-conversion values.

structure
     Called after setting and determining information on CSS, output files and directories, document structure and associated directions, file names, labels and links for nodes, sectioning commands, special elements, footnotes and index entries.

init
     Called after some gathering of global information on the document, such as titles, copying comment and document description, which require some conversion of Texinfo, right before the main output processing. At that point most of the information available from the converter is set (see Conversion General Information).

finish
     Called after output generation is finished.

The function used to register a user defined functions is texinfo_register_handler:

 -- Function: texinfo_register_handler ($stage, \&handler, $priority)
     $STAGE is one of the stages described just above. \&HANDLER is a reference on the user defined function. $PRIORITY is an optional priority class.

     To determine the order of user defined functions calls, the priority classes are sorted, and within a priority class the order is the order of calling texinfo_register_handler.

The call of the user defined functions is:

 -- Function Reference: $STATUS stage_handler
     ($CONVERTER, \%TREE, $STAGE)
     $CONVERTER is a converter object. \%TREE is the Texinfo tree root element. $STAGE is the current stage.

     If $STATUS is not 0 it means that an error occured. If $STATUS is positive, the user defined functions should have registered an error or warning message, for example with document_error (see Error Reporting in User Defined Functions). If $STATUS is negative, the converter will emit a non specific error message.  If the $STATUS is lower than -HANDLER_FATAL_ERROR_LEVEL or higher than HANDLER_FATAL_ERROR_LEVEL, the processing stops immediately.  Default value for HANDLER_FATAL_ERROR_LEVEL is 100.

User Defined Functions in Conversion
************************************

Full customization of output is achieved with replacing default formatting functions with user defined functions.  There are two broad classes of functions, the conversion functions used for elements of the Texinfo tree, and other formatting functions with diverse purposes, including formatting that are not based on tree elements (for example beginning and end of file formatting).

Tree Element Conversion Functions
=================================

Functions used for tree elements associated with @-commands are considered separately from functions used for tree elements not associated with @-commands, which includes containers with a type and text.  There are two functions for each element command or type, one called when the element is first encountered, and the other called after formatting the contents of the element.  The actual conversion is usually done after formatting the contents of the element, but it may sometime be necessary to have some code run when the element is first encountered.

Command Tree Element Opening Functions
--------------------------------------

User defined functions called when an @-command element is first encountered are registered with texinfo_register_command_opening:

 -- Function: texinfo_register_command_opening ($command_name, \&handler)
     $COMMAND_NAME is an @-command name, with the leading @. \&HANDLER is the user defined function reference.

The call of the user defined functions is:

 -- Function Reference: $TEXT command_open
     ($CONVERTER, $COMMAND_NAME, \%ELEMENT)
     $CONVERTER is a converter object. $COMMAND_NAME is the @-command name without the @. \%ELEMENT is the Texinfo element.

     The $TEXT returned is prepended to the formatting of the @-command.

It is possible to have access to the default opening function reference. The function used is:
 -- Function: \&DEFAULT_COMMAND_OPEN = $CONVERTER->default_command_open ($COMMAND_NAME)
     $COMMAND_NAME is the @-command name without the @. Returns the default opening function reference for $COMMAND_NAME, or undef if there is none.

Command Tree Element Conversion Functions
-----------------------------------------

User defined functions called for an @-command element conversion, after arguments and contents have been formatted, are registered with texinfo_register_command_formatting:

 -- Function: texinfo_register_command_formatting ($command_name, \&handler)
     $COMMAND_NAME is an @-command name, with the leading @. \&HANDLER is the user defined function reference.

The call of the user defined functions is:
 -- Function Reference: $TEXT command_conversion
     ($CONVERTER, $COMMAND_NAME, \%ELEMENT, \@ARGS, $CONTENT)
     $CONVERTER is a converter object. $COMMAND_NAME is the @-command name without the @. \%ELEMENT is the Texinfo element.

     \@ARGS, if defined, is a reference on the formatted arguments of the @-command. Each of the array items correspond to each of the @-command argument. Each array item is a hash references, with keys corresponding to possible argument formatting contexts:

     normal
          Argument formatted in a normal context

     monospace
          Argument formatted in a context where spaces are kept as is, as well as quotes and minus characters, for instance in -- and ``.  Both in preformatted and code context.  See Init File Expansion Contexts.

     monospacestring
          Same as monospace, but in addition in string context. See Init File Expansion Contexts.

     monospacetext
          Same as monospace, but in addition the argument is converted to plain text.  See Converter Object and Conversion Functions.

     raw
          Text is kept as is, special HTML characters are not protected.  Appears only as @inlineraw second argument.

     string
          In string context. See Init File Expansion Contexts.

     tree
          The Texinfo tree element corresponding to the argument. See Texinfo Tree Elements in User Defined Functions.

     url
          Similar with monospacetext.  The difference is that UTF-8 encoding is always used for the conversion of accented and special insertion @-commands to plain text.  This is best for percent encoding of url, which should always be produced from UTF-8 encoded strings.

     The formatted arguments contexts depend on the @-command, there could be none, for @footnote argument which is not directly converted where the footnote command is, or multiple, for example for the fourth argument of @image which is both available as normal and string.

     For example, $args->[0]->{'normal'} is the first argument converted in normal context.

     $CONTENT is the @-command formatted contents.  It corresponds to the contents of block @-commands, and to Texinfo code following @node, sectioning commands, @tab and @item in @enumerate and @itemize.  $CONTENT can be undef or the empty string.

     The $TEXT returned is the result of the @-command conversion.

To call a conversion function from user defined code, the function reference should first be retrieved using command_conversion:

 -- Function: \&COMMAND_CONVERSION = $CONVERTER->command_conversion ($COMMAND_NAME)
     $COMMAND_NAME is the @-command name without the @. Returns the conversion function reference for $COMMAND_NAME, or undef if there is none, which should only be the case for @-commands ignored in HTML not defined by the user.

for example, to call the conversion function for the @tab @-command, passing arguments that may correspond to another @-command:

     &{$converter->command_conversion('tab')}($converter, $cmdname,
                                          $command, $args, $content);

It is possible to have access to the default conversion function reference. The function used is:

 -- Function: \&DEFAULT_COMMAND_CONVERSION = $CONVERTER->default_command_conversion ($COMMAND_NAME)
     $COMMAND_NAME is the @-command name without the @. Returns the default conversion function reference for $COMMAND_NAME, or undef if there is none, which should only be the case for @-commands ignored in HTML.

Type Tree Element Opening Functions
-----------------------------------

User defined functions called when an element without @-command with a container type is first encountered are registered with texinfo_register_type_opening:

 -- Function: texinfo_register_type_opening ($type, \&handler)
     $TYPE is the element type. \&HANDLER is the user defined function reference.

The call of the user defined functions is:

 -- Function Reference: $TEXT type_open ($CONVERTER,
     $TYPE, \%ELEMENT)
     $CONVERTER is a converter object. $TYPE is the element type. \%ELEMENT is the Texinfo element.

     The $TEXT returned is prepended to the formatting of the type container.

It is possible to have access to the default opening function reference. The function used is:
 -- Function: \&DEFAULT_TYPE_OPEN = $CONVERTER->default_type_open ($TYPE)
     $COMMAND_NAME is the element type. Returns the default opening function reference for $TYPE, or undef if there is none.

Type Tree Element Conversion Functions
--------------------------------------

User defined functions called for the conversion of an element without @-command with text or a container type are registered with texinfo_register_type_formatting.  For containers, the user defined function is called after conversion of the content.

 -- Function: texinfo_register_type_formatting ($type, \&handler)
     $TYPE is the element type. \&HANDLER is the user defined function reference.

The call of the user defined functions is:

 -- Function Reference: $TEXT type_conversion ($CONVERTER,
     $TYPE, \%ELEMENT, $CONTENT)
     $CONVERTER is a converter object. $TYPE is the element type. \%ELEMENT is the Texinfo element.  $CONTENT is text for elements associated with text, or the formatted contents for other elements. $CONTENT can be undef or the empty string.

     The $TEXT returned is the result of the @-command conversion.

To call a conversion function from user defined code, the function reference should first be retrieved using type_conversion:

 -- Function: \&TYPE_CONVERSION = $CONVERTER->type_conversion ($TYPE)
     $TYPE is the element type.  Returns the conversion function reference for $TYPE, or undef if there is none, which should only be the case for types ignored in HTML not defined by the user.

It is possible to have access to the default conversion function reference. The function used is:

 -- Function: \&DEFAULT_TYPE_CONVERSION = $CONVERTER->default_type_conversion ($TYPE)
     $TYPE is the element type.  Returns the default conversion function reference for $TYPE, or undef if there is none, which should only be the case for types ignored in HTML.

Formatting Functions
====================

Most formatting functions are specific, with specific arguments, and a specific item formatted.

User defined functions associated with the formatting of special elements body (see Output Element Units) are handled separately.

The formatting functions are often called from function that can be replaced by a user defined function, therefore these functions may not be called if the replacement functions do not keep a similar operation.

Specific formating Functions
----------------------------

User defined formatting functions are registered with texinfo_register_formatting_function:

 -- Function: texinfo_register_formatting_function ($formatted,
     \&handler)
     $FORMATTED is a string describing the formatting function. \&HANDLER is the user defined function reference.

To call a formatting function from user defined code, the function reference should first be retrieved using formatting_function:

 -- Function: \&FORMATTING_FUNCTION = $CONVERTER->formatting_function ($FORMATTED)
     $FORMATTED is a string describing the formatting function. Returns the associated formatting function reference.

It is possible to have access to the default formatting function reference. The function used is:

 -- Function: \&DEFAULT_FORMATTING_FUNCTION = $CONVERTER->default_formatting_function ($FORMATTED)
     $FORMATTED is a string describing the formatting function. Returns the default formatting function reference.

The string that should be used to register or call each of the formatting functions and the call of the formatting functions are documented in the following sections of the manual, depending on where they are relevant.

Special Element Body Formatting Functions
-----------------------------------------

To register body formating user defined functions for special element (see Output Element Units), the special elements varieties are used, as described in Special Elements Varieties.

Special Element   Special Element Variety
Table of contents   contents
Short table of contents   shortcontents
Footnotes   footnotes
About   about

Table: Association of special elements names with their special element variety

Special element body formatting user defined functions are registered with texinfo_register_formatting_special_element_body:

 -- Function: texinfo_register_formatting_special_element_body ($special_element_variety,
     \&handler)
     $SPECIAL_ELEMENT_VARIETY is the element variety (see Special Elements Varieties).  \&HANDLER is the user defined function reference.

The call of the user defined functions is:
 -- Function Reference: $TEXT special_element_body ($CONVERTER,
     $SPECIAL_ELEMENT_VARIETY, \%ELEMENT)
     $CONVERTER is a converter object. $SPECIAL_ELEMENT_VARIETY is the element variety.  \%ELEMENT is the Texinfo element.

     The $TEXT returned is the formatted special element body.

To call a special element body formatting function from user defined code, the function reference should first be retrieved using special_element_body_formatting:

 -- Function: \&SPECIAL_ELEMENT_BODY_FORMATTING = $CONVERTER->special_element_body_formatting
     ($SPECIAL_ELEMENT_VARIETY)
     $SPECIAL_ELEMENT_VARIETY is the special element variety.  Returns the conversion function reference for $VARIETY, or undef if there is none, which should not happen for the special elements described in this manual.

For example:

     my $footnotes_element_body
      = &{$converter->special_element_body_formatting('footnotes')}($converter,
                                                          'footnotes', $element);

It is possible to have access to the default conversion function reference. The function used is:

 -- Function: \&DEFAULT_SPECIAL_ELEMENT_BODY_FORMATTING =
     $CONVERTER->defaults_special_element_body_formatting
     ($SPECIAL_ELEMENT_VARIETY)
     $SPECIAL_ELEMENT_VARIETY is the special element variety.  Returns the default conversion function reference for $SPECIAL_ELEMENT_VARIETY, or undef if there is none, which should not happen for the special elements described in this manual.

See Customizing Footnotes for more on the footnotes special element body formatting.  See Contents and Short Table of Contents Customization for more on the contents and shortcontents special elements body formatting.  See About Element Customization for more on the about special element body formatting.

Mandatory Conversion Function Calls
***********************************

There are several conventions and constraints that user defined code should abide to, in order to comply with customization option values, and also to have information correctly registered in the converter.

Protection of URLs
==================

URLs need to be ``percent-encoded'' to protect non-ASCII characters, spaces and other ASCII characters.  Percent-encoding also allows to have characters be interpreted as part of a path and not as characters with a special role in URLs.  For example, ? has a special role in URLs as it starts a query string.  To have it considered as part of a file path, instead of a marker of the beginning of a query, it needs to be percent encoded.

To protect a whole URL, in which characters with a special role in URL are left as is, use url_protect_url_text.  To protect file path in URL, including characters with a special role in URLs, use url_protect_file_text.

 -- Function: $PROTECTED_URL = $CONVERTER->url_protect_url_text($INPUT_STRING)
     Percent-encode $INPUT_STRING, leaving as is all the characters with a special role in URLs, such as :, /, ?, &, # or % (and a few other).  HTML reserved characters and form feeds protected are also protected as entities (see format_protect_text).  This is typically used on complete URLs pointing to diverse internet resources, such as the @url URL argument.

     for example

          return $self->html_attribute_class('a', [$cmdname])
               .' href="'.$self->url_protect_url_text($url)."\">$text</a>";

 -- Function: $PROTECTED_PATH = $CONVERTER->url_protect_file_text($INPUT_STRING)
     Percent-encode $INPUT_STRING leaving as is character appearing in file paths only, such as /, ., - or _.  All the other characters that can be percent-protected are protected, including characters with a special role in URLs.  For example, ?, & and % are percent-protected.  HTML reserved characters and form feeds protected are also protected as entities (see format_protect_text).  This is typically used on file names corresponding to actual files, used in the path portion of an URL, such as the image file path in @image.

     For example

          $self->html_attribute_class('img', [$cmdname])
             . ' src="'.$self->url_protect_file_text($image_file)."\");

Formatting HTML Element with Classes
====================================

Opening an HTML element with one or more classes should always be done through html_attribute_class:

 -- Function: $ELEMENT_OPEN = $CONVERTER->html_attribute_class
     ($HTML_ELEMENT, \@CLASSES)
     Formats the beginning of an HTML element $HTML_ELEMENT.  \@CLASSES is the list of classes for this element.  The element opening returned does not include the end of element symbol > such that it is possible to add more attributes.

     If the HTML element is span, an empty string is returned if there is also no attribute.

     If NO_CSS is set, no attribute is set for the element.  Otherwise a class attribute is set based on \@CLASSES . If INLINE_CSS_STYLE is set, a CSS style attribute based on CSS element class rules is also added.  Otherwise the information that the element class was seen is registered by the converter.

Examples of use:

     my $open = $converter->html_attribute_class('span', ['category-def']);
     $category_result = $open.'>'.$category_result.'</span>'
       if ($open ne '');

     my $result = $converter->html_attribute_class('em', [$cmdname, 'jax_p'])
          . '>' . $content . '</em>';

Closing Lone HTML Element
=========================

HTML elements with an opening element, but no closing element, such as <img> or <link> should be closed by calling close_html_lone_element:

 -- Function: $HTML_ELEMENT = $CONVERTER->close_html_lone_element
     ($UNCLOSED_ELEMENT)
     Close the $UNCLOSED_ELEMENT, which can contain attributes, by prepending > or /> depending on the USE_XML_SYNTAX customization variable value.

Examples of use:

     $description = $converter->close_html_lone_element(
         "<meta name=\"description\" content=\"$description\"");

Substituting Non Breaking Space
===============================

If a &nbsp; can appear in formatted code, the corresponding text should be in a call to substitute_html_non_breaking_space, to take into account ENABLE_ENCODING and USE_NUMERIC_ENTITY customization variables:

 -- Function: $SUBSTITUTED_TEXT = $CONVERTER->substitute_html_non_breaking_space
     ($FORMATTED_TEXT)
     Substitute &nbsp; according to customization variables values.

This is not needed if the non_breaking_space information is taken from the general information (see Conversion General Information).

Conversion in String Context
============================

Conversion and formatting functions should check if in string context to avoid using HTML elements in formatting when in string context. See Init File Expansion Contexts.

To determine if in string context, the functions is in_string:

 -- Function: $IN_STRING = $CONVERTER->in_string ()
     Return true if in string context.

Example of use:

     if ($converter->in_string()) {
       return "$mail_string ($text)";
     } else {
       return $converter->html_attribute_class('a', [$cmdname])
                           ." href=\"mailto:$mail_string\">$text</a>";
     }

Conversion in Preformatted Context
==================================

Conversion and formatting functions should test if in preformatted context to convert accordingly. See Init File Expansion Contexts.

To determine if in preformatted context, the functions is in_preformatted:

 -- Function: $IN_PREFORMATTED = $CONVERTER->in_preformatted ()
     Return true if in preformatted context.

If in preformatted context, it is possible to get preformatted @-commands and preformatted types nesting with preformatted_classes_stack:

 -- Function: @PREFORMATTED_NESTING = $CONVERTER->preformatted_classes_stack ()
     Returns an array containing the block preformatted @-commands such as @example, @display or @menu names without the leading @ and the HTML attribute class preformatted container names, in order of appearance.

The %Texinfo::Commands::preformatted_code_commands hash can be used to determine if a preformatted command is to be formatted as code (see Texinfo::Commands %preformatted_code_commands (texi2any_internals)).

     my @pre_classes = $converter->preformatted_classes_stack();
     foreach my $pre_class (@pre_classes) {
       if ($Texinfo::Commands::preformatted_code_commands{$pre_class}) {
         $result = '<code>' .$result. '</code>';
         last;
       }
     }

See Simple Customization of Containers on customizing containers preformatted class.

Text Formatting Context
=======================

Formatting of text requires to use additional informative functions on specific contexts only relevant for text.  User defined functions should convert the text according to the context.

Each context is associated with a function:

code

      -- Function: $IN_CODE = $CONVERTER->in_code ()
          Return true if in code context.  See Init File Expansion Contexts.

math

      -- Function: $IN_MATH = $CONVERTER->in_math ()
          Return true if in math context. See Init File Expansion Contexts.

raw

      -- Function: $IN_RAW = $CONVERTER->in_raw ()
          Return true if in raw format, in @inlineraw or in @html. In such a context, text should be kept as is and special HTML characters should not be protected.

verbatim

      -- Function: $IN_VERBATIM = $CONVERTER->in_verbatim ()
          Return true if in verbatim context, corresponding to @verb and @verbatim. In general, HTML characters should be protected in this context.

upper-case

      -- Function: $IN_UPPER_CASE = $CONVERTER->in_upper_case ()
          Return true if in upper-case context, corresponding to @sc.

non-breakable space

      -- Function: $IN_NON_BREAKABLE_SPACE = $CONVERTER->in_non_breakable_space ()
          Return true if in non-breakable space context, corresponding to @w.

Basic Formatting Customization
******************************

The following formatting functions references handle basic formatting and are called from diverse formatting and conversion functions. See Specific formating Functions for information on how to register and get the functions references.

All the functions take a converter object as their first argument.

format_button_icon_img

     Called for an active direction, if ICONS is set, when formatting the navigation panel (see Simple Navigation Panel Customization).

      -- Function Reference: $TEXT format_button_icon_img
          ($CONVERTER, $BUTTON, $ICON, $NAME)
          $BUTTON is a button name, typically obtained from the BUTTONS_NAME customization variable hash using a direction as key (see Directions). $ICON is an image file name to be used as icon.  $NAME is the direction heading, typically formatted in string context.  See Init File Expansion Contexts.

          Returns a formatted icon image.

format_comment

      -- Function Reference: $TEXT format_comment
          ($CONVERTER, $INPUT_TEXT)
          Return $INPUT_TEXT in a comment.

     See Texinfo::Convert::Converter::xml_comment (texi2any_internals).

format_heading_text

      -- Function Reference: $TEXT format_heading_text
          ($CONVERTER, $COMMAND_NAME, \@CLASSES, $INPUT_TEXT, $LEVEL, $ID, \%ELEMENT)
          Returns a heading formatted using $INPUT_TEXT as heading text, $LEVEL as heading level, \@CLASSES for a class attribute.  $COMMAND_NAME gives an information on the @-command the heading is associated to and can be undef, for instance for special elements headings.

          $ID is an optional identifier, and \%ELEMENT is an optional Texinfo tree element associated with the heading.

     This function reference can be called for @node and sectioning commands, heading commands, tree units, special elements and title @-commands.

     A formatted headings is, in the default case, like <h2>$INPUT_TEXT</h2> for a $LEVEL 2 heading.

format_program_string

      -- Function Reference: $TEXT format_program_string ($CONVERTER)
          This function reference should return the formatted program string.

format_protect_text
      -- Function Reference: $TEXT format_protect_text
          ($CONVERTER, $INPUT_TEXT)
          Return $INPUT_TEXT with HTML reserved characters and form feeds protected.

          For performance reasons, this function reference may not be called everywhere text is protected.  For those cases, the calling function should also be redefined to call &{$self->formatting_function('format_protect_text')}(...) instead of another function (The function called is actually the function referenced as $self->formatting_function('format_protect_text') in the default case, but it is called directly to avoid an indirection).

     See Texinfo::Convert::Converter::xml_protect_text (texi2any_internals).

format_separate_anchor

     This function reference is called if there is not another HTML element to add an identifier attribute to.

      -- Function Reference: $TEXT format_separate_anchor
          ($CONVERTER, $ID, $CLASS)
          ID is the identifier. $CLASS is an optional class to be used in an HTML class attribute.

          Return an anchor with identifier $ID.

Dynamic Conversion Information
******************************

Dynamic formatting information on the conversion can be obtained from the converter.

For advanced customization, it is also often necessary to pass information during conversion between different formatting functions or between different calls calls of the same function.

The information is often useful for the formatting of paragraph and preformatted containers and @-comands such as @abbr, @footnote, @node, sectioning commands, @quotation and @float.

Dynamic Converter Formatting Information
========================================

To get the current paragraph and preformatted number, use paragraph_number or preformatted_number:

 -- Function: $NUMBER = $CONVERTER->paragraph_number ()
 -- Function: $NUMBER = $CONVERTER->preformatted_number ()
     Return the current paragraph or preformatted container number in the current formatting context.

To get the topmost block @-command being converted, use top_block_command:
 -- Function: $COMMAND_NAME = $CONVERTER->top_block_command ()
     Return the most recent block @-command seen in the current formatting context.

To get the text filling and alignement context, determined by @flushleft or @center, use in_align:

 -- Function: $ALIGN_CONTEXT = $CONVERTER->in_align ()
     If the alignment context is the default alignement context, return undef. Otherwise, returns the command name of the alignment context.

To determine if the conversion is in a context converted multiple times, use in_multi_expanded:
 -- Function: $MULTI_EXPANDED_CONTEXT_INFORMATION = $CONVERTER->in_multi_expanded ()
     Return a string representing the multiple expanded context, or undef if not in a multiple expanded context.

To get the location of an image file, use html_image_file_location_name:

 -- Function: ($IMAGE_FILE, $IMAGE_BASEFILE, $IMAGE_EXTENSION, $IMAGE_PATH, $IMAGE_PATH_ENCODING) =
     $CONVERTER->html_image_file_location_name ($COMMAND_NAME, \%ELEMENT, \@ARGS)
     $COMMAND_NAME, \%ELEMENT and \@ARGS should be the arguments of an @image @-command formatting (see Command Tree Element Conversion Functions).

     The return values gives information on the image file if found, or fallback values. $IMAGE_FILE is the relative image file name.  It is the file name used in formatting of the @image command in the default case.  $IMAGE_BASEFILE is the base file name of the image, without extension, corresponding to the @image @-command first argument.  $IMAGE_EXTENSION is the image file extension (without a leading dot).  $IMAGE_PATH is the path to the actual image file, undef if no file was found.  $IMAGE_PATH is returned as a binary string, the other strings returned are character strings. $IMAGE_PATH_ENCODING is the encoding used to encode the image path to a binary string.

See Conversion in Preformatted Context for information on getting preformatted commands and container types nesting information.

Opening and Closing Sectioning Commands Extent
==============================================

In the default formatting, when a sectioning command is encountered, a <div> element is opened for the extent of the sectioning command including its children sectioning commands.  This extent need to be closed at different places, for instance when another sectioning command is reached, at the end of a file, or at the end of the document.

The user defined formatting function should take care of registering and closing opened section levels.  In the default code, registering is done in the sectioning commands conversion function only.

The function for registering opened section extent is register_opened_section_level:

 -- Function: $CONVERTER->register_opened_section_level ($level, $closing_text)
     $LEVEL is the sectioning command level.  It is typically obtained with section->{'structure'}->{'section_level'} (see Texinfo Tree Elements in User Defined Functions). $CLOSING_TEXT is the text that should be output when the section level $LEVEL is closed.

The function for closing registered section extents is close_registered_sections_level:

 -- Function: @CLOSING_TEXTS = $CONVERTER->close_registered_sections_level ($LEVEL)
     $LEVEL is the sectioning command level.  Opened section are closed down to section level $LEVEL.  The closing texts are returned in the @CLOSING_TEXTS array in order.

Example of use:

     my $level = $opening_section->{'structure'}->{'section_level'};
     $result .= join('', $converter->close_registered_sections_level($level));
     $converter->register_opened_section_level($level, "</div>\n");

Setting Up Content for the Next Text Container
==============================================

Text is mainly output in two inline text containers, paragraph for text in paragraph and preformatted for text in preformatted environments.  The Texinfo code parsing makes sure that it is the case, to simplify conversion to formats which allow text only in specific environments such as HTML.

Formatted text may also be prepared based on information from Texinfo elements tree while out of the inline containers.  For that case, functions allow to register pending inline formatted content, and get the content to be prepended in inline text containers.

Pending formatted content text is registered with register_pending_formatted_inline_content:

 -- Function: $CONVERTER->register_pending_formatted_inline_content ($category, $content)
     $CONTENT is the formatted content to be registered and output in the next inline container.  $CATEGORY is a indicator of the source of the formatted inline content, mostly used to cancel registered content if no inline container was seen.

Pending formatted content can (and should) be cancelled when it is known that there is no suitable inline container to be used to output the text.  The function is cancel_pending_formatted_inline_content:

 -- Function: $CANCELLED_CONTENT = $CONVERTER->cancel_pending_formatted_inline_content ($CATEGORY)
     Cancel the first $CATEGORY pending formatted content text found. Returns undef if nothing was cancelled, and the cancelled content otherwise.

Pending formatted content is gathered by calling get_pending_formatted_inline_content. In the default case, this is done in inline containers opening code (see Type Tree Element Opening Functions).

 -- Function: $CONTENT = $CONVERTER->get_pending_formatted_inline_content ()
     Returns the concatenated pending content.

The inline containers get the content when they are opened, but are converted after the formatting of their contents.  Two additional functions allow to associate pending content to an element, associate_pending_formatted_inline_content, and get the associated content, get_associated_formatted_inline_content. associate_pending_formatted_inline_content is normally called in inline container opening code, right after get_pending_formatted_inline_content, while get_associated_formatted_inline_content is called in the inline container conversion function (see Type Tree Element Conversion Functions).

 -- Function: $CONVERTER->associate_pending_formatted_inline_content (\%element, $content)
     Associate $CONTENT to the Texinfo tree element \%ELEMENT.

 -- Function: $CONTENT = $CONVERTER->get_associated_formatted_inline_content (\%ELEMENT)
     Get $CONTENT associated to the Texinfo tree element \%ELEMENT.

Associating Information to an Output File
=========================================

To be able to retrieve information associated to the current file, in general for the file begin or end formatting, register_file_information can  be used to associate information, and get_file_information to retrieve that information.

 -- Function: $CONVERTER->register_file_information ($key, $value)
     Associate the current output file name file to the key $KEY, itself associated to the value $VALUE.

 -- Function: $VALUE = $CONVERTER->get_file_information ($KEY, $FILE_NAME)
     Return the value associated to the key $KEY and file name $FILE_NAME.

Shared Conversion State
=======================

For information shared among formatting functions without involving the converter, the function shared_conversion_state can be used both for initialization of shared information and to share information:

 -- Function: $REFERENCE = $CONVERTER->shared_conversion_state ($NAME, $INITIALIZATION)
     Return the reference $REFERENCE associated with $NAME. $INITIALIZATION is only read the first time $NAME is seen and sets up the reference that will be reused afterwards.  If $INITIALIZATION is a scalar (string or integer, for example), a reference on a scalar is returned, the associated value being set to $INITIALIZATION.  Otherwise, $INITIALIZATION should be a reference on a hash or on an array.

The converter is used to hold the information, but does not use nor write.

Examples of use:

     my $explained_commands_hash
         = $converter->shared_conversion_state('explained_commands', {});
     $explained_commands_hash->{'key'} = 'value';

     my $foot_num_reference
          = $converter->shared_conversion_state('footnote_number', 0);
     ${$foot_num_reference}++;

Directions, Links, Labels and Files
***********************************

Navigation headers, navigation panels, end or beginning of files, @xref and similar @-commands output, @menu, @node, sectioning commands, @printindex and @listoffloats formatting requires directions, links, labels and files information.

Target Commands Links, Texts and Associated Commands
====================================================

Target @-commands are @-comands that are associated with an identifier and can be linked to.  They corresponds first to @-commands with unique identifier used as labels, @node, @anchor and @float.  Sectioning commands, index entries and footnotes are also associated to targets.

To get the unique Texinfo tree element corresponding to a label, use label_command:

 -- Function: \%ELEMENT = $CONVERTER->label_command ($LABEL)
     Return the element in the tree that $LABEL refers to.

To get the identifier, file name and href of tree elements that may be used as link target, use command_id, command_filename and command_href:

 -- Function: $IDENTIFIER = $CONVERTER->command_id (\%TARGET_ELEMENT)
     Returns the id specific of the \%TARGET_ELEMENT tree element.

 -- Function: $FILE_NAME = $CONVERTER->command_filename (\%TARGET_ELEMENT)
     Returns the file name of the \%TARGET_ELEMENT tree element.

 -- Function: $HREF = $CONVERTER->command_href (\%TARGET_ELEMENT,
     $SOURCE_FILENAME, $SOURCE_COMMAND, $SPECIFIED_TARGET)
     Return string for linking to \%TARGET_ELEMENT with <a href>. $SOURCE_FILENAME is the file the link comes from. If not set, the current file name is used.  $SOURCE_COMMAND is an optional argument, the @-command the link comes from.  It is only used for messages. $SPECIFIED_TARGET is an optional identifier that overrides the target identifier if set.

To get the text of tree elements that may be used as link description, use command_text:

 -- Function: $RESULT = $CONVERTER->command_text (\%TARGET_ELEMENT, $TYPE)
     Return the information to be used for a hyperlink to \%TARGET_ELEMENT. The information returned depends on $TYPE:

     text
          Return text.

     tree
          Return a Texinfo elements tree.

     tree_nonumber
          Return a Texinfo elements tree representing text without a chapter number being included.

     string
          Return text in string context.  See Init File Expansion Contexts.

To obtain the top level command element associated with the target element, either a @node or a sectioning element, use command_root_element_command:

 -- Function: \%TOP_LEVEL_ELEMENT = $CONVERTER->command_root_element_command
     (\%TARGET_ELEMENT)
     Return the top level element \%TARGET_ELEMENT is in.

To get the node element associated with the target element, use command_node:

 -- Function: \%NODE_ELEMENT = $CONVERTER->command_node (\%TARGET_ELEMENT)
     Return the node element associated with \%TARGET_ELEMENT.

Other Links, Headings and Associated Information for Special Elements
=====================================================================

To get the id of a footnote in the main document, use footnote_location_target:

 -- Function: $TARGET = $CONVERTER->footnote_location_target (\%FOOTNOTE_ELEMENT)
     Return the id for the location of the footnote \%FOOTNOTE_ELEMENT in the main document (where the footnote number or symbol appears).

To get an href to link to a footnote location in the main document, use footnote_location_href:

 -- Function: $HREF = $CONVERTER->footnote_location_href (\%FOOTNOTE_ELEMENT,
     $SOURCE_FILENAME, $SPECIFIED_TARGET, $TARGET_FILENAME)
     Return string for linking to \%FOOTNOTE_ELEMENT location in the main document with <a href>.  $SOURCE_FILENAME is the file the link comes from. If not set, the current file name is used. $SPECIFIED_TARGET is an optional identifier that overrides the target identifier if set.  $TARGET_FILENAME is an optional file name that overrides the file name href part if set.

See Target Commands Links, Texts and Associated Commands to get link information for the location where footnote text is output.

To get id and link href of sectioning commands in table of contents and short table of contents, use command_contents_target and command_contents_href:

 -- Function: $TARGET = $CONVERTER->command_contents_target
     (\%SECTIONING_ELEMENT, $CONTENTS_OR_SHORTCONTENTS)
     Returns the id for the location of \%SECTIONING_ELEMENT sectioning element in the table of contents, if $CONTENTS_OR_SHORTCONTENTS is contents, or in the short table of contents, if $CONTENTS_OR_SHORTCONTENTS is set to shortcontents or summarycontents.

 -- Function: $HREF = $CONVERTER->command_contents_href
     (\%SECTIONING_ELEMENT, $CONTENTS_OR_SHORTCONTENTS, $SOURCE_FILENAME)
     Return string for linking to the \%SECTIONING_ELEMENT sectioning element location in the table of contents, if $CONTENTS_OR_SHORTCONTENTS is contents or in the short table of contents, if $CONTENTS_OR_SHORTCONTENTS is set to shortcontents or summarycontents.  $SOURCE_FILENAME is the file the link comes from. If not set, the current file name is used.

To determine if a tree unit element is the top element, use element_is_tree_unit_top:

 -- Function: $IS_TREE_UNIT_TOP = $CONVERTER->element_is_tree_unit_top (\%ELEMENT)
     Returns true if the \%ELEMENT Texinfo tree element is the tree unit Top element (see Output Element Units) and is either associated with the @top sectioning command or with the Top @node.

To get information on the special element variety associated with an @-command command name, use command_name_special_element_information:

 -- Function: ($SPECIAL_ELEMENT_VARIETY, \%SPECIAL_ELEMENT, $CLASS_BASE, $SPECIAL_ELEMENT_DIRECTION) =
     $CONVERTER->command_name_special_element_information ($COMMAND_NAME)
     $COMMAND_NAME is an @-command name without the leading @. If the $COMMAND_NAME is not associated with a special element, returns undef.  Otherwise, return the $SPECIAL_ELEMENT_VARIETY (see Special Elements Varieties), the \%SPECIAL_ELEMENT texinfo tree unit, a $CLASS_BASE string for HTML class attribute and the $SPECIAL_ELEMENT_DIRECTION direction corresponding to that special elements (see Directions).

In the current setup, special elements are associated with @contents, @shortcontents and @summarycontents and with @footnote.

Elements and Links for Directions
=================================

See Directions for the list of directions.

To get the Texinfo tree unit special element associated with a special element direction, such as About or Contents, use special_direction_element:

 -- Function: \%SPECIAL_ELEMENT = $CONVERTER->special_direction_element ($DIRECTION)
     Return the special element associated with direction $DIRECTION, or undef if the direction is not a special element direction or the special element is not output.

To get the Texinfo tree unit element associated with other global element directions, such as Top or Index, use global_direction_element:

 -- Function: \%ELEMENT = $CONVERTER->global_direction_element ($DIRECTION)
     Return the Texinfo tree unit element corresponding to direction $DIRECTION, or undef if the direction is not a global direction.

To get link information for relative and global directions, use from_element_direction:

 -- Function: $RESULT = $CONVERTER->from_element_direction ($DIRECTION, $TYPE,
     $SOURCE_ELEMENT, $SOURCE_FILENAME, $SOURCE_COMMAND)
     Return a string for linking to $DIRECTION, or the information to be used for a hyperlink to $DIRECTION, depending on $TYPE. The possible values for $TYPE are described in Element Direction Information Type.

     $SOURCE_ELEMENT is the tree unit element the link comes from. If not set, the current tree unit element is used.  $SOURCE_FILENAME is the file the link comes from. If not set, the current file name is used. $SOURCE_COMMAND is an optional argument, the @-command the link comes from. It is only used for messages.

Element Counters in Files
=========================

The position of the tree unit element being formatted in its file or the total number of elements output to a file is interesting, for instance to format end of files, decide which navigation header or footer is needed and whether a rule should be output.

To get information on tree elements unit counter in files, use count_elements_in_filename:

 -- Function: $COUNT = $CONVERTER->count_elements_in_filename
     ($SPECIFICATION, $FILE_NAME)
     Return tree unit element counter for $FILE_NAME, or undef if the counter does not exist.  The counter returned depends on $SPECIFICATION:

     current
          Return the number of unit elements associated with $FILE_NAME having already been processed.

     remaining
          Return the number of unit elements associated with $FILE_NAME that remains to be processed.

     total
          Return the total number of element units associated with the file.

Customizing Footnotes, Tables of Contents and About
***************************************************

Customizing Footnotes
=====================

NUMBER_FOOTNOTES and NO_NUMBER_FOOTNOTE_SYMBOL customization variables can be used to change the footnotes formatting.  Redefinition of @footnote conversion reference and footnote formatting references is needed for further customization.

@footnote @-commands appearing in the Texinfo elements tree are converted like any other elements associated with @-commands (see Command Tree Element Conversion Functions).  It is therefore possible to redefine their formatting by registering a user defined function.

To pass information on footnotes between the conversion function processing the @footnote command at the location they appear in the document and the functions formatting their argument elsewhere, two functions are available: register_footnote to be called where they appear in the document, and get_pending_footnotes to be called where they are formatted.

 -- Function: $CONVERTER->register_footnote (\%element, $footnote_id,
     $foot_in_doc_id, $number_in_doc, $footnote_location_filename, $multi_expanded_region)
     \%ELEMENT is the footnote texinfo tree element. $FOOTNOTE_ID is the identifier for the location where the footnote arguments are expanded. $FOOT_IN_DOC_ID is the identifier for the location where the footnote appears in the document.  $NUMBER_IN_DOC is the symbol used to format the footnote in the document.  $FOOTNOTE_LOCATION_FILENAME is the filename of the tree unit element of the footnote in the document. If the footnote appears in a region that is expanded multiple times, the information on the expansion is $MULTI_EXPANDED_REGION (see Dynamic Converter Formatting Information).

register_footnote is normally called in the @footnote @-command conversion function reference.  The default conversion function also call command_href to link to the location where the footnote text will be expanded (see Target Commands Links, Texts and Associated Commands).

 -- Function: @PENDING_FOOTNOTES_INFORMATION = $CONVERTER->get_pending_footnotes ()
     Returns in @PENDING_FOOTNOTES_INFORMATION the information gathered in register_footnote.  Each of the array element in @PENDING_FOOTNOTES_INFORMATION is an array reference containing the arguments of register_footnote in the same order.

The formatting of footnotes content is done by the format_footnotes_sequence formatting reference (see Specific formating Functions):

 -- Function Reference: $FOOTNOTES_SEQUENCE format_footnotes_sequence
     ($CONVERTER)
     Formats and returns the footnotes that need to be formatted.  This function normally calls get_pending_footnotes.  The default function also calls footnote_location_href (see Other Links, Headings and Associated Information for Special Elements) to link to the location in the document where the footnote appeared.

If footnotes are in a separate element unit (see Output Element Units), the default footnote special element body formatting function calls format_footnotes_sequence (see Special Element Body Formatting Functions).

If the footnotes are not in a separate element unit, or there is no separate element because there is only one tree unit element or no tree unit element, the format_footnotes_segment formatting reference is called when pending footnotes need to be formatted.  This function reference can be replaced by a user defined function.

 -- Function Reference: $FOOTNOTES_SEGMENT format_footnotes_segment
     ($CONVERTER)
     Returns the footnotes formatted.  In the default case, the function reference calls format_footnotes_sequence and also sets up a header with format_heading_text (see Basic Formatting Customization), using the customization variables FOOTNOTE_END_HEADER_LEVEL and SPECIAL_ELEMENTS_HEADING with the footnotes special element variety key.

Contents and Short Table of Contents Customization
==================================================

To begin with, the table of contents and short table of contents can be made to appear at different locations in the document.

By default, the customization variable CONTENTS_OUTPUT_LOCATION is set to after_top, specifying that the tables of contents are output at the end of the @top section, to have the main location for navigation in the whole document early on.  This is in line with FORMAT_MENU set to sectiontoc with sectioning command being used in HTML for navigation rather than menus.

If CONTENTS_OUTPUT_LOCATION is set to inline, the tables of content are output where the corresponding @-command, for example @contents, is set.  This behavior is consistent with texi2dvi.

If CONTENTS_OUTPUT_LOCATION is set to separate_element, the tables of contents are output in separate elements, either at the end of the document if the output is unsplit or in separate files if not. This makes sense when menus are used for navigation with FORMAT_MENU set to menu.

If CONTENTS_OUTPUT_LOCATION is set to after_title the tables of contents are merged into the title material, which in turn is not output by default; see HTML Title Page Customization.

Next, the following variables allow for some useful control of the formatting of table of contents and short table of contents:

BEFORE_TOC_LINES
     Inserted before the table of contents text.

AFTER_TOC_LINES
     Inserted after the table of contents text.

BEFORE_SHORT_TOC_LINES
     Inserted before the short table of contents text.

AFTER_SHORT_TOC_LINES
     Inserted after the short table of contents text.

Additional customization variables SHORT_TOC_LINK_TO_TOC and NUMBER_SECTIONS can be used to change the formatting of table of contents.

Finally, the following function reference provides even more control over the table of contents and short table of contents formatting reference:

 -- Function Reference: $TOC_RESULT format_contents
     ($CONVERTER, $COMMAND_NAME, \%ELEMENT, $FILENAME)
     $COMMAND_NAME is the @-command name without leading @, should be contents, shortcontents or summarycontents. \%ELEMENT is optional.  It corresponds to the $COMMAND_NAME Texinfo tree element, but it is only set if format_contents is called from a Texinfo tree element conversion, and not as a special element body formatting. $FILENAME is optional and should correspond to the filename where the formatting happens, for links.

     In the default function, structuring information is used to format the table of contents (see Conversion General Information), and command_contents_href (see Other Links, Headings and Associated Information for Special Elements) and command_href (see Target Commands Links, Texts and Associated Commands) are used for links.  If $FILENAME is unset, the current file name is used, using $converter->get_info('current_filename').

     Return formatted table of contents or short table of contents.

If contents are in a separate element unit (see Output Element Units), the default contents and shortcontents special element body formatting function calls format_contents (see Special Element Body Formatting Functions).  Otherwise, format_contents is called in the conversion of heading @-command, in title page formatting, and in @contents conversion function, depending on the CONTENTS_OUTPUT_LOCATION value.

About Element Customization
===========================

The default About element has an explanation of the buttons used in the document, controlled by SECTION_BUTTONS. The formatting of this text may be influenced by BUTTONS_GOTO, BUTTONS_NAME, ACTIVE_ICONS (see Simple Navigation Panel Customization).

BUTTONS_EXAMPLE also influences the formatting. The keys of this hash are element directions (see Directions) and the values are the text from the About example, typically a section number.

PROGRAM_NAME_IN_ABOUT can also be used to change the beginning of the About element formatting.

If the above is not enough and you want to control exactly the formatting of the about element, the about special element body reference function may be overridden (see Special Element Body Formatting Functions).

Customizing HTML Footers, Headers and Navigation Panels
*******************************************************

texi2any provides for customization of the HTML page headers, footers, and navigation panel.  (These are unrelated to the headings and ``footings'' produced in TeX output; see Page Headings (Texinfo).)

In the event that your needs are not met by changing the navigation buttons (see Simple Navigation Panel Customization), you can completely control the formatting of navigation panels by redefining function references. See Specific formating Functions for information on how to register the function references.

In a nutshell, element header and footer formatting function determines the button directions list to use and calls navigation header formatting.  The navigation header formatting adds some formatting if needed, but mostly calls the navigation panel formatting.  The navigation panel can call buttons formatting.

Navigation Panel and Navigation Header Formatting
=================================================

All the formatting functions take a converter object as first argument.

The overall display of navigation panels is controlled via this function reference, format_navigation_header:

 -- Function Reference: $NAVIGATION_TEXT format_navigation_header
     ($CONVERTER, \@BUTTONS, $COMMAND_NAME, \%ELEMENT)
     \@BUTTONS is an array reference holding the specification of the buttons for the navigation panel (see Simple Navigation Panel Customization). \%ELEMENT is the element in which the navigation header is formatted. $COMMAND_NAME is the associated command (sectioning command or @node).  It may be undef for special elements.

     Returns the formatted navigation header and panel. The navigation panel itself can be formatted with a call to &{$self->formatting_function('format_navigation_panel')}.

     The customization variable VERTICAL_HEAD_NAVIGATION should be relevant.

The navigation panel display is controlled via format_navigation_panel:

 -- Function Reference: $NAVIGATION_TEXT format_navigation_panel
     ($CONVERTER, \@BUTTONS, $COMMAND_NAME, \%ELEMENT, $VERTICAL)
     \@BUTTONS is an array reference holding the specification of the buttons for that navigation panel.   \%ELEMENT is the element in which the navigation header is formatted. $COMMAND_NAME is the associated command (sectioning command or @node).  It may be undef for special elements.  $VERTICAL is true if the navigation panel should be vertical.

     Returns the formatted navigation panel in $NAVIGATION_TEXT. The buttons in the navigation panel can be formatted with a call to &{$self->formatting_function('format_button')}.

The function reference format_button does the formatting of one button:

 -- Function Reference: $FORMATTED_BUTTON format_button
     ($CONVERTER, $BUTTON, $SOURCE_COMMAND)
     $BUTTON holds the specification of the button (see Buttons Display). $SOURCE_COMMAND is an optional argument, the @-command the link comes from.

     Returns the formatted result in $FORMATTED_BUTTON.

     The buttons images can be formatted with format_button_icon_img (see Basic Formatting Customization).

     Customization information described in Simple Navigation Panel Customization such as BUTTONS_TEXT, BUTTONS_NAME, BUTTONS_GOTO, USE_ACCESSKEY, BUTTONS_ACCESSKEY, USE_REL_REV and BUTTONS_REL can be relevant for the formatting of a button.

Element Header and Footer Formatting
====================================

All the formatting functions take a converter object as first argument.

By default, the function associated with format_element_header formats the header and navigation panel of a tree unit element.

 -- Function Reference: $FORMATTED_HEADER format_element_header
     ($CONVERTER, $COMMAND_NAME, \%ELEMENT, \%TREE_UNIT_ELEMENT)
     \%ELEMENT is the element in which the navigation header is formatted (sectioning command, @node or special element). $COMMAND_NAME is the associated command name.  It may be undef for special elements. \%TREE_UNIT_ELEMENT is the associated tree unit element (see Texinfo Tree Elements in User Defined Functions).

     Returns the formatted navigation header and panel.

     In the default code, the function reference select a buttons list (see Simple Navigation Panel Customization).  The navigation header can then be formatted with a call to &{$self->formatting_function('format_navigation_header')}.  It is also possible to format directly the navigation panel, depending on customization variables values and location in file.

Similarly, the function associated with format_element_footer formats the footer and navigation panel of a tree unit element.

 -- Function Reference: $FORMATTED_FOOTER format_element_footer
     ($CONVERTER, $TREE_UNIT_TYPE, \%TREE_UNIT_ELEMENT,
     $CONTENT, $COMMAND)
     \%TREE_UNIT_ELEMENT is the tree unit element element in which the navigation footer is formatted.  $TREE_UNIT_TYPE is the associated type. $CONTENT is the formatted element content.  $COMMAND is an optional argument, the @-command associated with the \%TREE_UNIT_ELEMENT.

     Returns the formatted navigation footer and panel.

     In the default code, the function reference select a buttons list (see Simple Navigation Panel Customization). The navigation header can then be formatted with a call to &{$self->formatting_function('format_navigation_header')}.

     Many customization variables may be interesting for the footer formatting, such as SPLIT, HEADERS, DEFAULT_RULE, BIG_RULE, WORDS_IN_PAGE or PROGRAM_NAME_IN_FOOTER.

Heading Commands and Tree Elements Formatting
*********************************************

The customization variables CONTENTS_OUTPUT_LOCATION, CHAPTER_HEADER_LEVEL, TOC_LINKS and FORMAT_MENU may be used to change the sectioning commands conversion. See HTML Customization Variables (Texinfo).

@node and sectioning default conversion function call format_heading_text (see Basic Formatting Customization) and format_element_header (see Element Header and Footer Formatting), as well as functions opening and closing sectioning commands extent (see Opening and Closing Sectioning Commands Extent).  The @node and sectioning elements are formatted like any other elements associated with @-commands.  The corresponding function references can therefore be replaced by user defined functions for a precise control of conversion (see Command Tree Element Conversion Functions).

Tree unit elements default conversion involves calling the formatting reference format_element_footer (see Element Header and Footer Formatting). The conversion for these elements with type unit can be be replaced by user defined functions for a precise control of conversion (see Type Tree Element Conversion Functions).

Special elements conversion is achieved by calling special_element_body_formatting (see Special Element Body Formatting Functions), format_navigation_header (see Navigation Panel and Navigation Header Formatting), format_heading_text (see Basic Formatting Customization) and format_element_footer (see Element Header and Footer Formatting).  The conversion for these elements with type special_element_type can be be replaced by user defined functions for a precise control of conversion (see Type Tree Element Conversion Functions).

Specific customization variable hashes taking special element varieties as keys are used in special elements formatting:

SPECIAL_ELEMENTS_HEADING
     heading text of the special element.

SPECIAL_ELEMENTS_CLASS
     string for special element HTML class attributes.

SPECIAL_ELEMENTS_DIRECTIONS
     direction corresponding to the special element. See Directions.

Beginning and Ending Files
**************************

The end of file (footers) formatting function reference is called from the converter after all the element units in the file have been converted. The beginning of file (headers) formatting function reference is called right after the footers formatting function reference.

See Specific formating Functions for information on how to register and get the functions references.

Customizing HTML File Beginning
===============================

You can set the variable DOCTYPE to replace the default. the DOCTYPE is output at the very beginning of each output file.

You can define the variable EXTRA_HEAD to add text within the <head> HTML element.  Similarly, the value of AFTER_BODY_OPEN is added just after <body> is output. These variables are empty by default.

The <body> element attributes may be set by defining the customization variable BODYTEXT.

By default, the encoding name from ENCODING_NAME is used.  If this variable is not defined, it is automatically determined.

A date is output in the header if DATE_IN_HEADER is set.

The description from @documentdescription (or a value set as a customization variable) is used in the header (see @documentdescription (Texinfo)).

<link> elements are used in the header if USE_LINKS is set, in which case LINKS_BUTTONS determines which links are used and BUTTONS_REL determines the link type associated with the rel attribute.  See Simple Navigation Panel Customization.

You can set HTML_ROOT_ELEMENT_ATTRIBUTES to add attributes to the <html> element.

The customization variables SECTION_NAME_IN_TITLE, PACKAGE_AND_VERSION, PACKAGE_URL and other similar variables, HTML_MATH and INFO_JS_DIR may also be used to change the page header formatting. See HTML Customization Variables (Texinfo).

The following function references give full control over the page header formatting done at the top of each HTML output file.

 -- Function Reference: $FILE_BEGIN format_begin_file
     ($CONVERTER, $FILENAME, \%TREE_UNIT_ELEMENT)
     $FILENAME is the name of the file output. \%TREE_UNIT_ELEMENT is the first tree unit element of the file. This function should print the page header, in HTML, including the <body> element.

Customizing HTML File End
=========================

You can define the variable PRE_BODY_CLOSE to add text just before the HTML </body> element.  Nothing is added by default.

If PROGRAM_NAME_IN_FOOTER is set, the date and name of the program that generated the output are output in the footer.

The customization variables JS_WEBLABELS and JS_WEBLABELS_FILE are also used in the page footer formatting. See HTML Customization Variables (Texinfo).

The format_end_file function reference give full control over the page footer formatting done at the bottom of each HTML output file.

 -- Function Reference: $FILE_END format_end_file
     ($CONVERTER, $FILENAME)
     $FILENAME is the name of the file output. This function should print the page footer, including the </body> element.

Titlepage, CSS and Redirection Files
************************************

HTML Title Page Customization
=============================

If SHOW_TITLE is not set, no title is output.  SHOW_TITLE is undef in the default case.  If undef, SHOW_TITLE is set if NO_TOP_NODE_OUTPUT is set.  The ``title page'' is used to format the HTML title if USE_TITLEPAGE_FOR_TITLE is set, otherwise the simpletitle is used.  USE_TITLEPAGE_FOR_TITLE is set in the default case.  See HTML Customization Variables (Texinfo).

The following functions references provides full control on the title and ``title page'' formatting:

 -- Function Reference: $TITLE_TITLEPAGE format_title_titlepage ($CONVERTER)
     Returns the formatted title or ``title page'' text.

     In the default case, return nothing if SHOW_TITLE is not set, return the output of format_titlepage if USE_TITLEPAGE_FOR_TITLE is set, and otherwise output a simple title based on simpletitle.

 -- Function Reference: $TITLE_PAGE format_titlepage ($CONVERTER)
     Returns the formatted ``title page'' text.

     In the default case, the @titlepage is used if found in global information, otherwise simpletitle is used (see Conversion General Information).

Customizing the CSS lines
=========================

See Simple Customization of CSS for information on CSS customization.

The CSS ELEMENT.CLASS that appeared in a file, gathered through html_attribute_class calls (see Formatting HTML Element with Classes) are available through the html_get_css_elements_classes function:

 -- Function: @CSS_ELEMENT_CLASSES = $CONVERTER->html_get_css_elements_classes
     ($FILE_NAME)
     Returns an array containing element.class pairs of elements and classes appearing in $FILE_NAME.

It is possible to change completely how CSS lines are generated by redefining the following function reference:

 -- Function Reference: $CSS_LINES format_css_lines
     ($CONVERTER, $FILE_NAME)
     This function returns the CSS lines and <script> HTML element for $FILE_NAME.

     In the default case, the function reference uses CSS_REFS corresponding to command-line --css-ref, html_get_css_elements_classes and css_get_info (see Simple Customization of CSS) to determine the CSS lines.

Customizing Node Redirection Pages
==================================

Node redirection pages are output if NODE_FILES is set (see Invoking texi2any (Texinfo)).

It is possible to change completely how node redirection pages are generated by redefining the following function reference:

 -- Function Reference: $NODE_REDIRECTION_FILE_CONTENT
     format_node_redirection_page ($CONVERTER, \%ELEMENT)
     \%ELEMENT is a node element needing a redirection page.  A redirection page is needed if the node file name is not the file name expected for HTML cross manual references (see HTML Xref (Texinfo)).

     Returns the content of the node redirection file.

Specific Functions for Specific Elements
****************************************

Links on Texinfo perl modules functions or descriptions of functions that can be used for specific elements formatting:

@today
     See Texinfo::Convert::Utils::expand_today (texi2any_internals).

@verbatiminclude
     See Texinfo::Convert::Utils::expand_verbatiminclude (texi2any_internals).

@def* @-commands
     See Texinfo::Convert::Utils::definition_arguments_content (texi2any_internals). See Texinfo::Convert::Utils::definition_category_tree (texi2any_internals).

@float
     See Texinfo::Convert::Converter::float_name_caption (texi2any_internals). Can be called as $converter->float_name_caption.

accent @-commands
     See Texinfo::Convert::Converter::xml_accent (texi2any_internals). Can be called as $converter->xml_accent.

     See Texinfo::Convert::Converter::xml_numeric_entity_accent (texi2any_internals).

     See Texinfo::Convert::Converter::convert_accents (texi2any_internals).

text element
     See Texinfo::Convert::Converter::xml_format_text_with_numeric_entities (texi2any_internals). Can be called as $converter->xml_format_text_with_numeric_entities.

@item in @table and similar @-commands
     See Texinfo::Convert::Converter::table_item_content_tree (texi2any_internals). Can be called as $converter->table_item_content_tree.

@*index @subentry
     See Texinfo::Convert::Converter::comma_index_subentries_tree (texi2any_internals). Can be called as $converter->comma_index_subentries_tree.

global informative commands (@contents, @footnotestyle ...)
     See Texinfo::Common::set_informative_command_value (texi2any_internals).

heading commands, such as @subheading
     See Texinfo::Common::section_level (texi2any_internals).  This function would work for sectioning commands too, but for sectioning commands, section->{'structure'}->{'section_level'} can also be used. See Texinfo Tree Elements in User Defined Functions.

sectioning commands
     See Texinfo::Structuring::section_level_adjusted_command_name (texi2any_internals).

@itemize
     @itemize normally have an @-command as argument.  If, instead, the argument is some Texinfo code, html_convert_css_string_for_list_mark can be used to convert that argument to text usable in CSS style specifications.

      -- Function: $TEXT_FOR_CSS = $CONVERTER->html_convert_css_string_for_list_mark
          (\%ELEMENT, $EXPLANATION)
          \%ELEMENT is the Texinfo element that is converted to CSS text. In general, it is $itemize->{'args'}->[0], with $itemize an @itemize Texinfo tree element.  $EXPLANATION is an optional string describing what is being done that can be useful for debugging.

          Returns \%ELEMENT formatted as text suitable for CSS.

The Texinfo::Convert::NodeNameNormalization converter, used for normalization of labels, exports functions that can be used on Texinfo elements trees to obtain strings that are unique and can be used in attributes. See Texinfo::Convert::NodeNameNormalization (texi2any_internals).