| # LaTeX.pm: output tree as LaTeX |
| # |
| # Copyright 2010-2022 Free Software Foundation, Inc. |
| # |
| # This program is free software; you can redistribute it and/or modify |
| # it under the terms of the GNU General Public License as published by |
| # the Free Software Foundation; either version 3 of the License, |
| # or (at your option) any later version. |
| # |
| # This program is distributed in the hope that it will be useful, |
| # but WITHOUT ANY WARRANTY; without even the implied warranty of |
| # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| # GNU General Public License for more details. |
| # |
| # You should have received a copy of the GNU General Public License |
| # along with this program. If not, see <http://www.gnu.org/licenses/>. |
| # |
| # TODO |
| # |
| # RELEVANT BUT NOT DECISIVE |
| # |
| # If @allowcodebreaks is false, - should be set such that it is not a |
| # breaking point anymore. |
| # |
| # Note that the texinfo.tex code does more, for instance turns off normal |
| # hyphenation, sets plainfrenchspacing (see \tclose), and sets line breaks |
| # at _ and - with several special cases, such as no break right after one |
| # or two hyphen, no break between __ or hyphen. See near \global\def\code |
| # in texinfo.tex. |
| # |
| # |
| # breaking in urls is not implemented, maybe there is some support already in |
| # hyperref. @urefbreakstyle, @/ |
| # |
| # Need some thinking/discussion for translations. In texi2any? In LaTeX? If |
| # in texi2any in general no need for something as complex as gdt leading to a |
| # Texinfo tree, as we can provide strings to be translated already in LaTeX |
| # with the same property than Texinfo strings with LaTeX commands avoiding, |
| # to some extent, dependence on the language and/or encoding. |
| # |
| # It seems that \chaptername doesn't become Appendix for a sectioning command |
| # appearing after \appendix |
| # |
| # command that could be used for translation \sectionname does not exist in the |
| # default case. it is defined in the pagenote package together with \pagename |
| # which is page in the default case, but it is unclear if this can be used as a |
| # basis for translations |
| # |
| # The @afourpaper, @afourlatex and @afourwide commands all map to |
| # papername=a4paper. It is most likely ok for @afourlatex, but the other two |
| # should be associated with other geometries. |
| # |
| # The \geometry command does not really reset the geometry after |
| # \begin{document} according to the documentation, something else should be |
| # used to switch paper definition after document begin if needed. Not |
| # necessarily a bad thing not to be able to change paper geometry after the |
| # beginning of the document. |
| # |
| # @pagesizes uses \newgeometry which forgets about previous settings except for |
| # paper size. It could be a good thing to change geometry that way, but it is |
| # not how Texinfo TeX does it. |
| # |
| # The environment used for @quotation is quote as it seems to match in term of |
| # output, but the description of quote does not really match with what is |
| # supposed to be the @quotation output. |
| # |
| # Proper indenting of nested environments, @exdent from nested environment |
| # |
| # should we percent encode @email and @uref/@url urls? |
| # |
| # Some customization would be relevant, for example the |
| # document type, fonts, packages... In particular, as reported by Karl, |
| # people will surely want to run xelatex or lualatex and use ttf/otf |
| # fonts, which means getting rid of the {fontenc} call entirely. (And |
| # using \usepackage{fontspec}\usepackage{unicode-math} instead.) |
| # We can also imagine people wanting different euro symbols. |
| # Maybe each one of the default \usepackage's should be configurable. |
| # |
| # @shortcontents is not implemented. Tried shorttoc package but it |
| # has two limitations that are not in Texinfo, need a main \tableofcontents |
| # and need to be before @contents. A code snippet looked good for a |
| # @shortcontents after @contents, but not before: |
| #{ |
| #\renewcommand*{\contentsname}{Short contents} |
| #\setcounter{tocdepth}{0} |
| #\expandafter\def\csname @starttoc\endcsname#1{\InputIfFileExists{\jobname.#1}{}{}}% |
| #\tableofcontents |
| #} |
| # We could treat LaTeX like HTML with CONTENTS_OUTPUT_LOCATION=aftertop and |
| # ignore both @contents and @shortcontents. |
| # |
| # it seems that \indent only works with \setlength{\parindent}{0pt} |
| # which makes it quite different from Texinfo @indent. Implement |
| # something differently to have the expected output with @indent? |
| # |
| # |
| # CAN WAIT |
| # |
| # Use texinfo.cnf? Here? in texi2any.pl? |
| # |
| # @need is implemented in a specific way, maybe there could be a definition of |
| # \mil instead. |
| # |
| # @group is not implemented. We could try the minipage environment. |
| # |
| # @fonttextsize with \changefontsize does not seems to change fonts much. It |
| # seems to change in the text, but only 10pt, and does not seems to change |
| # sections font sizes. |
| # |
| # The \listof formatting does not look so good. Also it does not use the type |
| # (name) of float. |
| # |
| # in TeX, acronym is in a smaller font (1pt less). Can this be easily done in |
| # LaTeX? Is it really useful to do that? |
| # |
| # interline spacing in @title multi lines in @titlepage and between multiple |
| # @author is not as good as in Texinfo TeX output/ example titlepage_classical |
| # in t/latex_tests.t can show it. |
| # |
| # shorttitlepage in Texinfo TeX does not seem to break line. Probably ok. |
| # |
| # for external references it seems that Texinfo TeX points to a file, it could |
| # be relevant to do the same in LaTeX. |
| # |
| # Nothing specific is done for @headings singleafter and @headings doubleafter |
| # compared to @headings single and @headings double |
| # |
| # The support of \global\urefurlonlylinktrue would be rather easy, but |
| # need to make it a proper @-command first. Similar for |
| # \global\def\linkcolor and \global\def\urlcolor. There are options for |
| # colors in hyperref, like linkbordercolor but it is unclear whether it |
| # can be used to distinguish links and urls. |
| # |
| # In the manual it is said that majorheading generates a larger vertical |
| # whitespace before the heading than @chapheading command. It is not |
| # implemented. However, it seems that the chapter level commands in LaTeX |
| # generate bigger fonts and much more vertical whitespace than in Texinfo TeX |
| # so maybe it is not needed to do something here. |
| # |
| # index entry between @table and first @item causes an empty \item[] to be |
| # output. |
| # |
| # @headitem row is not formatted differently from an item row. It is |
| # possible to use the multitable_head to get the same information. |
| # |
| # if there is a prototype for a multitable, it is converted to plain |
| # text to determine the fraction. If it was done differently, @headitemfont |
| # may need to be processed, too. |
| # |
| # In Texinfo TeX, @code{@slanted{slanted in code}} and |
| # @slanted{@code{code in slanted}} are different, |
| # @slanted{@code{code in slanted}} is not slanted. |
| # According to Karl, we should not try to specify what nested style commands |
| # should be formatted as. So this should probably not be considered |
| # as an issue, at least until we get user reports. |
| # https://lists.gnu.org/archive/html/bug-texinfo/2006-06/msg00030.html |
| # |
| # @indentedblock and @smallindentedblock should not have a wider right |
| # margin. The wider margin is because they are in quote environment. |
| # |
| # @def* body should not have a wider right margin. The wider margin |
| # is because they are in quote environment. |
| |
| package Texinfo::Convert::LaTeX; |
| |
| use 5.00405; |
| |
| # See comment at start of HTML.pm |
| use if $] >= 5.012, feature => qw(unicode_strings); |
| |
| use strict; |
| |
| # To check if there is no erroneous autovivification |
| #no autovivification qw(fetch delete exists store strict); |
| |
| use File::Spec; |
| |
| use Carp qw(cluck confess); |
| |
| use Texinfo::Commands; |
| use Texinfo::Common; |
| use Texinfo::Convert::Texinfo; |
| use Texinfo::Convert::NodeNameNormalization; |
| use Texinfo::Convert::Text; |
| use Texinfo::Convert::Converter; |
| |
| use vars qw($VERSION @ISA); |
| @ISA = qw(Texinfo::Convert::Converter); |
| |
| $VERSION = '7.0.3'; |
| |
| # could export convert_to_latex_math |
| |
| |
| # commands that are of use for formatting. |
| my %formatted_line_commands = %Texinfo::Common::formatted_line_commands; |
| my %formatted_nobrace_commands = %Texinfo::Common::formatted_nobrace_commands; |
| my %formattable_line_commands = %Texinfo::Common::formattable_line_commands; |
| |
| my %paper_geometry_commands = ( |
| 'afourpaper' => 'papername=a4paper', |
| 'afourlatex' => 'papername=a4paper', |
| 'afourwide' => 'papername=a4paper', |
| 'afivepaper' => 'papername=a5paper', |
| 'bsixpaper' => 'papername=b6paper', |
| 'smallbook' => 'paperheight=9.25in,paperwidth=7in', |
| ); |
| |
| my %informative_commands; |
| foreach my $informative_command (keys (%Texinfo::Common::document_settable_at_commands)) { |
| $informative_commands{$informative_command} = 1; |
| } |
| |
| my %brace_no_arg_commands; |
| foreach my $command (keys (%Texinfo::Commands::brace_commands)) { |
| $brace_no_arg_commands{$command} = 1 |
| if ($Texinfo::Commands::brace_commands{$command} eq 'noarg'); |
| } |
| my %accent_commands = %Texinfo::Commands::accent_commands; |
| my %line_commands = %Texinfo::Commands::line_commands; |
| my %nobrace_commands = %Texinfo::Commands::nobrace_commands; |
| my %sectioning_heading_commands = %Texinfo::Commands::sectioning_heading_commands; |
| my %def_commands = %Texinfo::Commands::def_commands; |
| my %ref_commands = %Texinfo::Commands::ref_commands; |
| my %block_commands = %Texinfo::Commands::block_commands; |
| my %root_commands = %Texinfo::Commands::root_commands; |
| my %preformatted_commands = %Texinfo::Commands::preformatted_commands; |
| my %math_commands = %Texinfo::Commands::math_commands; |
| my %preformatted_code_commands = %Texinfo::Commands::preformatted_code_commands; |
| my %default_index_commands = %Texinfo::Commands::default_index_commands; |
| my %heading_spec_commands = %Texinfo::Commands::heading_spec_commands; |
| my %letter_no_arg_commands = %Texinfo::Commands::letter_no_arg_commands; |
| |
| my %nobrace_symbol_text = %Texinfo::Common::nobrace_symbol_text; |
| my %explained_commands = %Texinfo::Common::explained_commands; |
| my %inline_format_commands = %Texinfo::Common::inline_format_commands; |
| my %brace_code_commands = %Texinfo::Common::brace_code_commands; |
| my %unformatted_brace_command = %Texinfo::Common::unformatted_brace_command; |
| |
| my %preamble_commands = %Texinfo::Common::preamble_commands; |
| |
| foreach my $kept_command (keys(%informative_commands), |
| keys(%default_index_commands), |
| keys(%formattable_line_commands)) { |
| $formatted_line_commands{$kept_command} = 1; |
| } |
| |
| foreach my $def_command (keys(%def_commands)) { |
| $formatted_line_commands{$def_command} = 1 if ($line_commands{$def_command}); |
| } |
| |
| # TODO command that could be used for translation \sectionname does |
| # not exist in the default case. it is defined in the pagenote package |
| # together with \pagename which is page in the default case, but it is unclear |
| # if this can be used as a basis for translations |
| my %LaTeX_in_heading_commands_formatting = ( |
| # default for texinfo.tex is similar: |
| # \putwordChapter{} \thischapternum: \thischaptername} |
| # see doc/txi-zh.tex for how it could be in chinese |
| 'thischapter' => '\chaptername{} \thechapter{} \chaptertitle{}', |
| 'thischaptername' => '\chaptertitle{}', |
| 'thischapternum' => '\thechapter{}', |
| # default for texinfo.tex is similar: |
| # \putwordSection{} \thissectionnum: \thissectionname} |
| #'thissection' => '\sectionname{} \thesection{} \sectiontitle{}', |
| 'thissection' => 'Section \thesection{} \sectiontitle{}', |
| 'thissectionname' => '\sectiontitle{}', |
| 'thissectionnum' => '\thesection{}', |
| 'thisfile' => '', |
| 'thispage' => '\thepage{}', |
| 'thistitle' => '\Texinfosettitle{}', |
| ); |
| |
| foreach my $kept_command (keys(%LaTeX_in_heading_commands_formatting), |
| 'indent', 'noindent') { |
| $formatted_nobrace_commands{$kept_command} = 1; |
| } |
| |
| my %block_math_commands; |
| foreach my $block_math_command (keys(%math_commands)) { |
| if (exists($block_commands{$block_math_command})) { |
| $block_math_commands{$block_math_command} = 1; |
| } |
| } |
| |
| my %ignored_line_commands; |
| foreach my $line_command (keys(%line_commands)) { |
| $ignored_line_commands{$line_command} = 1 |
| unless ($formatted_line_commands{$line_command}); |
| } |
| |
| my %ignored_nobrace_commands; |
| foreach my $nobrace_command (keys(%nobrace_commands)) { |
| $ignored_nobrace_commands{$nobrace_command} = 1 |
| unless ($formatted_nobrace_commands{$nobrace_command}); |
| } |
| |
| # from \def\Gin@extensions in graphics-def/pdftex.def |
| my @LaTeX_image_extensions = ( |
| 'pdf','png','jpg','mps','jpeg','jbig2','jb2','PDF','PNG','JPG','JPEG','JBIG2','JB2'); |
| |
| my %section_map = ( |
| 'top' => 'part*', |
| 'part' => 'part', |
| 'chapter' => 'chapter', |
| 'section' => 'section', |
| 'subsection' => 'subsection', |
| 'subsubsection' => 'subsubsection', |
| # embed in a \Texinfonopagebreakheading call to remove pagebreaks |
| 'chapheading' => 'Texinfonopagebreakheading{\chapter*}', |
| 'majorheading' => 'Texinfonopagebreakheading{\chapter*}', |
| 'heading' => 'section*', |
| 'subheading' => 'subsection*', |
| 'subsubheading' => 'subsubsection*', |
| 'unnumbered' => 'chapter*', |
| 'centerchap' => 'chapter*', |
| 'unnumberedsec' => 'section*', |
| 'unnumberedsubsec' => 'subsection*', |
| 'unnumberedsubsubsec' => 'subsubsection*', |
| 'appendix' => 'chapter', |
| 'appendixsec' => 'section', |
| 'appendixsubsec' => 'subsection', |
| 'appendixsubsubsec' => 'subsubsection', |
| ); |
| |
| my %LaTeX_no_arg_brace_commands = ( |
| # textmode |
| 'cmd_text' => { |
| 'TeX' => '\TeX{}', |
| 'LaTeX' => '\LaTeX{}', |
| 'bullet' => '\textbullet{}', |
| 'copyright' => '\copyright{}', |
| 'registeredsymbol' => '\circledR{}', |
| 'dots' => '\dots{}\@', |
| 'enddots' => '\dots{}', |
| 'equiv' => '$\equiv{}$', |
| 'error' => '\fbox{error}', |
| 'expansion' => '$\mapsto{}$', |
| 'arrow' => '$\rightarrow{}$', |
| 'minus' => '-', |
| 'point' => '$\star{}$', |
| 'print' => '$\dashv{}$', |
| 'result' => '$\Rightarrow{}$', |
| 'pounds' => '\textsterling{}', |
| 'atchar', => '@', |
| 'lbracechar' => '\{', |
| 'rbracechar' => '\}', |
| 'backslashchar' => '\textbackslash{}', |
| 'hashchar' => '\#', |
| 'comma' => ',', |
| 'ampchar' => '\&', |
| 'euro' => '\euro{}', |
| 'geq' => '$\geq{}$', |
| 'leq' => '$\leq{}$', |
| 'textdegree' => '\textdegree{}', |
| 'today' => '\today{}', |
| 'tie' => '~' |
| }, |
| 'cmd_math' => { |
| # error in math with \TeX \LaTeX, spacing command used not allowed |
| # so use plain text |
| 'TeX' => 'TeX', |
| 'LaTeX' => 'LaTeX', |
| 'bullet' => '\bullet{}', |
| 'copyright' => '\copyright{}', |
| 'registeredsymbol' => '\circledR{}', |
| 'dots' => '\dots{}', |
| 'enddots' => '\dots{}', |
| 'equiv' => '\equiv{}', |
| 'error' => '\fbox{error}', |
| 'expansion' => '\mapsto{}', |
| 'arrow' => '\rightarrow{}', |
| 'minus' => '-', |
| 'point' => '\star{}', |
| 'print' => '\dashv{}', |
| 'result' => '\Rightarrow{}', |
| 'pounds' => '\mathsterling{}', |
| 'atchar', => '@', |
| 'lbracechar' => '\{', |
| 'rbracechar' => '\}', |
| # this follows the Texinfo manual, however there is no obvious |
| # visible effect |
| 'backslashchar' => '\mathtt{\backslash{}}', |
| 'hashchar' => '\#', |
| 'comma' => ',', |
| 'ampchar' => '\&', |
| 'euro' => '\euro{}', |
| 'geq' => '\geq{}', |
| 'leq' => '\leq{}', |
| 'textdegree' => '^{\circ{}}', |
| 'today' => '\today{}', |
| 'tie' => '\hbox{}', |
| } |
| ); |
| |
| # the corresponding LaTeX commands can only appear in text mode |
| # so we switch to text mode to output them if in math |
| my %LaTeX_text_only_no_arg_brace_commands = ( |
| 'exclamdown' => 'textexclamdown', |
| 'questiondown' => 'textquestiondown', |
| 'ordf' => 'textordfeminine', |
| 'ordm' => 'textordmasculine', |
| 'quotedblleft' => 'textquotedblleft', |
| 'quotedblright' => 'textquotedblright', |
| 'quoteleft' => 'textquoteleft', |
| 'quoteright' => 'textquoteright', |
| 'quotedblbase' => 'quotedblbase', |
| 'quotesinglbase' => 'quotesinglbase', |
| 'guillemetleft', => 'guillemotleft', |
| 'guillemetright' => 'guillemotright', |
| 'guillemotleft' => 'guillemotleft', |
| 'guillemotright' => 'guillemotright', |
| 'guilsinglleft' => 'guilsinglleft', |
| 'guilsinglright' => 'guilsinglright', |
| ); |
| |
| foreach my $letter_no_arg_command ('aa','AA','ae','oe','AE','OE','o','O', |
| 'ss','l','L','DH','dh','TH','th') { |
| $LaTeX_text_only_no_arg_brace_commands{$letter_no_arg_command} |
| = $letter_no_arg_command; |
| } |
| |
| foreach my $text_only_no_arg_brace_command |
| (keys(%LaTeX_text_only_no_arg_brace_commands)) { |
| my $LaTeX_command = |
| "\\$LaTeX_text_only_no_arg_brace_commands{$text_only_no_arg_brace_command}\{\}"; |
| $LaTeX_no_arg_brace_commands{'cmd_text'}->{$text_only_no_arg_brace_command} |
| = $LaTeX_command; |
| $LaTeX_no_arg_brace_commands{'cmd_math'}->{$text_only_no_arg_brace_command} |
| = '\mathord{\text{'.$LaTeX_command.'}}'; |
| } |
| |
| # dotless is special |
| my %LaTeX_accent_commands = ( |
| # textmode |
| 'cmd_text' => { |
| ',' => 'c', |
| 'ringaccent' => 'r', |
| 'H' => 'H', |
| 'dotaccent' => '.', |
| 'ubaraccent' => 'b', |
| 'udotaccent' => 'd', |
| 'ogonek' => 'k', |
| 'tieaccent' => 't', |
| }, |
| 'cmd_math' => { |
| '"' => 'ddot', |
| '~' => 'tilde', |
| '^' => 'hat', |
| '`' => 'grave', |
| "'" => 'acute', |
| '=' => 'bar', |
| 'ringaccent' => 'mathring', |
| 'dotaccent' => 'dot', |
| 'u' => 'breve', |
| 'v' => 'check', |
| } |
| ); |
| |
| foreach my $accent_command (keys %{$LaTeX_accent_commands{'cmd_math'}}) { |
| if (not exists($LaTeX_accent_commands{'cmd_text'}->{$accent_command})) { |
| $LaTeX_accent_commands{'cmd_text'}->{$accent_command} = $accent_command; |
| } |
| } |
| |
| |
| my %ignored_commands = (%ignored_line_commands, %ignored_nobrace_commands); |
| # processed as part of the index command or type formatting, or ignored. |
| foreach my $ignored_brace_commands ( |
| 'sortas', 'seeentry', 'seealso', 'errormsg') { |
| $ignored_commands{$ignored_brace_commands} = 1; |
| } |
| |
| # titlepage content is directly formatted at document begin |
| foreach my $ignored_block_commands ('ignore', 'macro', 'rmacro', 'copying', |
| 'documentdescription', 'titlepage') { |
| $ignored_commands{$ignored_block_commands} = 1; |
| } |
| |
| my %LaTeX_list_environments = ( |
| 'itemize' => 'itemize', |
| 'enumerate' => 'enumerate', |
| ); |
| |
| my %format_raw_commands; |
| foreach my $block_command (keys(%block_commands)) { |
| $ignored_commands{$block_command} = 1 |
| if ($block_commands{$block_command} eq 'menu'); |
| $LaTeX_list_environments{$block_command} = 'description' |
| if ($block_commands{$block_command} eq 'item_line'); |
| $format_raw_commands{$block_command} = 1 |
| if ($block_commands{$block_command} eq 'format_raw'); |
| } |
| |
| my %block_raw_commands = %format_raw_commands; |
| foreach my $block_raw_command ('verbatim') { |
| $block_raw_commands{$block_raw_command} = 1 |
| } |
| |
| my @LaTeX_same_block_commands = ( |
| 'titlepage', 'verbatim'); |
| |
| my $small_font_size = 'footnotesize'; |
| |
| my %LaTeX_environment_commands = ( |
| 'raggedright' => ['flushleft'], |
| 'flushleft' => ['flushleft', 'Texinfopreformatted'], |
| 'flushright' => ['flushright', 'Texinfopreformatted'], |
| 'quotation' => ['quote'], |
| 'smallquotation' => ['quote', $small_font_size], |
| 'indentedblock' => ['quote'], |
| 'smallindentedblock' => ['quote', $small_font_size], |
| 'cartouche' => ['mdframed'], |
| 'itemize' => ['itemize'], |
| 'enumerate' => ['enumerate'], |
| 'table' => ['description'], |
| 'vtable' => ['description'], |
| 'ftable' => ['description'], |
| 'example' => ['Texinfoindented'], |
| 'lisp' => ['Texinfoindented'], |
| 'display' => ['Texinfoindented'], |
| ); |
| |
| my %LaTeX_environment_options = ( |
| 'cartouche' => {'mdframed' => 'style=Texinfocartouche'}, |
| ); |
| |
| my %LaTeX_environment_packages = ( |
| 'cartouche' => ['mdframed'], |
| ); |
| |
| my %LaTeX_fixed_width_environments = ( |
| 'verbatim' => 1, |
| 'Texinfopreformatted' => 1, |
| ); |
| |
| foreach my $environment_command (@LaTeX_same_block_commands) { |
| $LaTeX_environment_commands{$environment_command} = [$environment_command]; |
| } |
| |
| my %ignorable_space_types; |
| foreach my $type ('ignorable_spaces_after_command', |
| 'spaces_at_end', |
| 'spaces_after_close_brace') { |
| $ignorable_space_types{$type} = 1; |
| } |
| |
| # ignore 'command_as_argument_inserted' in order to use the default |
| # setting for @itemize if there is no argument |
| my %ignored_types; |
| foreach my $type ('preamble_before_beginning', |
| 'preamble_before_setfilename', 'command_as_argument_inserted') { |
| $ignored_types{$type} = 1; |
| } |
| |
| my %ignorable_types = %ignorable_space_types; |
| foreach my $ignored_type(keys(%ignored_types)) { |
| $ignorable_types{$ignored_type} = 1; |
| } |
| |
| # The following code is used to define style commands with more |
| # complex code than a LaTeX command. |
| # |
| # It was designed initially to setup combined fonts similar to texinfo.tex |
| # fonts, corresponding to code like \ttsl, combining typewriter and slanted. |
| # The idea was to use constructs like \ttfamily\textsl to have a cumulative |
| # effect. However, it seems that a constructs like \texttt{\textsl{cumulate}} |
| # do combine the styles, so nothing complex is needed for that case. |
| # |
| # As a side note it is not so easy to check the font type combinations |
| # results as they depend on the fonts. With \usepackage[T1]{fontenc}, |
| # used in the default case, there is no difference between typewriter |
| # and bold + typewriter, and \textbf{{\ttfamily\textsl{kbd in strong}}} |
| # seems to be in italic. it is better to look at the results with |
| # \usepackage{lmodern}. |
| |
| my $style_command_new_commands_prefix = 'Texinfocommandstyle'; |
| # if new commands are setup for styles, they are in this hash |
| my %style_brace_format_command_new_commands; |
| |
| # setup a new command |
| sub register_style_format_command($$$$$) |
| { |
| my $formatting_context = shift; |
| my $command = shift; |
| my $formatting = shift; |
| my $style_ref = shift; |
| my $new_commands_ref = shift; |
| |
| # 'cmd_text' to 'text' |
| my $formatting_context_text = $formatting_context; |
| $formatting_context_text =~ s/^cmd_//; |
| |
| my $specific_style_command_name |
| = "${style_command_new_commands_prefix}${formatting_context_text}$command"; |
| my $specific_style_command = '\\'.$specific_style_command_name; |
| $style_ref->{$formatting_context}->{$command} = $specific_style_command; |
| $new_commands_ref->{$formatting_context}->{$command} |
| = "$specific_style_command\[1]{{$formatting\{#1}}}"; |
| return $specific_style_command_name; |
| } |
| |
| # @-commands that stop code context |
| my %roman_style_commands = ( |
| 'r' => 1, |
| ); |
| |
| # All those commands run with the text. |
| # math and verb are special and implemented separately. |
| # There is specific code for some commands, such as kbd, r |
| # in addition to using this hash. |
| my %LaTeX_style_brace_commands = ( |
| 'cmd_text' => { |
| 'hyphenation' => '\\hyphenation', |
| 'w' => '\\hbox', |
| 'sub' => '\\textsubscript', |
| 'sup' => '\\textsuperscript', |
| 'r' => '\\textnormal', |
| 'sc' => '\\textsc', |
| 'sansserif' => '\\textsf', |
| }, |
| 'cmd_math' => { |
| 'hyphenation' => '', |
| 'w' => '\\hbox', |
| 'sub' => '_', |
| 'sup' => '^', |
| 'r' => '\\mathrm', |
| 'sc' => '', # no obvious way to do it in math mode, not switching to |
| # text mode only for this command |
| 'sansserif' => '\\mathsf', |
| } |
| ); |
| |
| foreach my $context (keys(%LaTeX_style_brace_commands)) { |
| $style_brace_format_command_new_commands{$context} = {}; |
| } |
| |
| # embrac does not propagate in these commands. But we want |
| # upside braces in these commands. So we make them known to |
| # embrac. Only locally, otherwise other commands can be broken. |
| my %need_known_embrac; |
| # other commands needed? |
| foreach my $LaTeX_style_command_name ('textsc', 'textbf', 'texttt') { |
| $need_known_embrac{'\\'.$LaTeX_style_command_name} = $LaTeX_style_command_name; |
| } |
| |
| # we want to keep those @-commands in roman slanted everywhere in text |
| # so use \normalfont{} to remove other font effects |
| foreach my $always_slanted_roman_commands ('cite', 'var') { |
| register_style_format_command('cmd_text', $always_slanted_roman_commands, |
| '\\normalfont{}\\textsl', \%LaTeX_style_brace_commands, |
| \%style_brace_format_command_new_commands); |
| # it seems better to use explicitly mathit, otherwise the space between |
| # the letters in argument can be important for some letters (such as ff), |
| # corresponding to letters being multiplied rather than to words, which |
| # is a better interpretation for @-command arguments. |
| # https://tex.stackexchange.com/questions/448069/fix-ugly-kerning-in-equation-subscript |
| # In tests, \mathnormal didn't avoid the issue, and numbers |
| # were small, so use \mathit, which also slants the numbers. |
| $LaTeX_style_brace_commands{'cmd_math'}->{$always_slanted_roman_commands} |
| = '\\mathit'; |
| $roman_style_commands{$always_slanted_roman_commands} = 1; |
| } |
| |
| # specific style for kbd: slanted and typewriter. code @-command |
| # formatting is used instead if needed, see _kbd_code_style. |
| register_style_format_command('cmd_text', 'kbd', |
| '\\ttfamily\\textsl', \%LaTeX_style_brace_commands, |
| \%style_brace_format_command_new_commands); |
| |
| # FIXME headitemfont |
| my @asis_commands = ('asis', 'clicksequence', 'headitemfont'); |
| |
| foreach my $asis_command (@asis_commands) { |
| $LaTeX_style_brace_commands{'cmd_text'}->{$asis_command} = ''; |
| $LaTeX_style_brace_commands{'cmd_math'}->{$asis_command} = ''; |
| } |
| |
| # in texinfo.tex, @dfn is slanted. |
| my @slanted_commands = ('dfn', 'slanted'); |
| foreach my $slanted_command (@slanted_commands) { |
| $LaTeX_style_brace_commands{'cmd_text'}->{$slanted_command} = '\\textsl'; |
| $LaTeX_style_brace_commands{'cmd_math'}->{$slanted_command} = '\\mathit'; |
| } |
| |
| my @emphasized_commands = ('emph'); |
| foreach my $emphasized_command (@emphasized_commands) { |
| $LaTeX_style_brace_commands{'cmd_text'}->{$emphasized_command} = '\\emph'; |
| $LaTeX_style_brace_commands{'cmd_math'}->{$emphasized_command} = '\\mathit'; |
| } |
| |
| my @bold_commands = ('strong', 'b'); |
| foreach my $bold_command (@bold_commands) { |
| $LaTeX_style_brace_commands{'cmd_text'}->{$bold_command} = '\\textbf'; |
| $LaTeX_style_brace_commands{'cmd_math'}->{$bold_command} = '\\mathbf'; |
| } |
| |
| my @italics_commands = ('i'); |
| foreach my $italics_command (@italics_commands) { |
| $LaTeX_style_brace_commands{'cmd_text'}->{$italics_command} = '\\textit'; |
| $LaTeX_style_brace_commands{'cmd_math'}->{$italics_command} = '\\mathit'; |
| } |
| |
| my @typewriter_commands = ('t', 'code', 'samp', 'key', 'env', 'file', |
| 'command', 'option', 'indicateurl'); |
| |
| foreach my $typewriter_command (@typewriter_commands) { |
| $LaTeX_style_brace_commands{'cmd_text'}->{$typewriter_command} = '\\texttt'; |
| $LaTeX_style_brace_commands{'cmd_math'}->{$typewriter_command} = '\\mathtt'; |
| } |
| |
| my @quoted_commands = ('samp', 'indicateurl'); |
| |
| my %quotes_map; |
| # Quotes are reset in converter_initialize and unicode quotes are used |
| # if @documentencoding utf-8 is used. |
| foreach my $quoted_command (@quoted_commands) { |
| $quotes_map{$quoted_command} = ["`", "'"]; |
| } |
| |
| # Format in description for @*table argument |
| |
| # note that if each command was formatted with format= option of |
| # enumitem \description, the command would need to be formatted |
| # with a final command, and possibly in a default bold font |
| # that would need to be isolated with \normalfont. However, since |
| # a parbox with each items on different lines is used to avoid having |
| # too much spacing, there is no such constraint. In any case, commands |
| # are defined for every style command if needed. |
| my %description_command_format; |
| |
| my $description_command_new_commands_prefix = 'Texinfotablestyle'; |
| |
| # if new commands are setup for descriptions, they are in this hash |
| my %description_command_new_commands = (); |
| |
| foreach my $command (keys(%{$LaTeX_style_brace_commands{'cmd_text'}})) { |
| # avoids hyphenation @-command |
| next if ($unformatted_brace_command{$command}); |
| my $description_format = $LaTeX_style_brace_commands{'cmd_text'}->{$command}; |
| |
| if ($quotes_map{$command}) { |
| # Setup command used to format in tables for quoted commands. Note that |
| # the quotes used in that context are not modified by OUTPUT_ENCODING_NAME |
| # nor *_QUOTE_SYMBOL. |
| my $specific_format_command |
| = "\\${description_command_new_commands_prefix}$command"; |
| # does not happen currently |
| if ($description_format eq '') { |
| $description_command_new_commands{$command} = |
| "$specific_format_command\[1]{\\ifstrempty{#1}{}{{`#1'}}"; |
| } else { |
| # We use \ifstrempty to avoid outputting an empty |
| # quotation if there is no item. Note that it does |
| # not work as intended if there is no optional parameter |
| # for item, like |
| # \item some text |
| # but works for |
| # \item[] some text |
| $description_command_new_commands{$command} |
| = "$specific_format_command\[1]{\\ifstrempty{#1}{}{`$description_format\{#1}'}}"; |
| } |
| $description_command_format{$command} = $specific_format_command; |
| } elsif ($description_format ne '') { |
| $description_command_format{$command} = $description_format; |
| } |
| } |
| |
| |
| my %defaults = ( |
| 'ENABLE_ENCODING' => 0, |
| 'FORMAT_MENU' => 'nomenu', |
| 'EXTENSION' => 'tex', |
| |
| 'documentlanguage' => undef, |
| |
| 'converted_format' => 'latex', |
| |
| # FIXME this sets an option that is not a customization variable |
| # and will not be documented anywhere. It should probably be better |
| # to add and document a customization in the Texinfo manual if needed. |
| # For LaTeX in general, it could make sense to have some customization, |
| # for example of packages, fonts, document type, to be discussed/though |
| # about how to setup this customization. |
| # FIXME any idea what could be used? |
| 'floats_extension' => 'tfl', |
| ); |
| |
| |
| sub converter_defaults($$) |
| { |
| return %defaults; |
| } |
| |
| # Converter state keys: |
| # |
| # custom_heading |
| # description_format_commands |
| # extra_definitions: Texinfo specific LaTeX command definitions that |
| # need to be output based on the commands used to |
| # format the Texinfo code |
| # fixed_width_environments: fixed width environment used for formatting |
| # formatting_context: formatting context information for a whole context, |
| # for instance in a footnote. See _push_new_context |
| # for the list of items set in formatting_context. |
| # index_entries |
| # indices_information |
| # list_environments |
| # latex_floats |
| # normalized_float_latex |
| # normalized_nodes_associated_section: associates anchor and node not already |
| # associated to section to the next or previous section. |
| # packages: packages needed by the LaTeX formatting of Texinfo code |
| # page_styles |
| # style_brace_format_commands |
| |
| sub converter_initialize($) |
| { |
| my $self = shift; |
| |
| %{$self->{'ignored_types'}} = %ignored_types; |
| %{$self->{'ignorable_space_types'}} = %ignorable_space_types; |
| %{$self->{'ignored_commands'}} = %ignored_commands; |
| |
| foreach my $format (keys(%format_raw_commands)) { |
| $self->{'ignored_commands'}->{$format} = 1 |
| unless ($self->{'expanded_formats_hash'}->{$format}); |
| } |
| |
| %{$self->{'quotes_map'}} = %quotes_map; |
| $self->{'convert_text_options'} |
| = {Texinfo::Convert::Text::copy_options_for_convert_text($self, 1)}; |
| |
| # this condition means that there is no way to turn off |
| # @U expansion to utf-8 characters even though this |
| # could output characters that are not known in the |
| # fontenc and will lead to an error. |
| # This is described in the Texinfo manual, but not in |
| # in a precise way. |
| # FIXME add a customization variable? Use a fontenc with more points? |
| if ($self->get_conf('OUTPUT_ENCODING_NAME') |
| and $self->get_conf('OUTPUT_ENCODING_NAME') eq 'utf-8') { |
| # cache this to avoid redoing calls to get_conf |
| $self->{'to_utf8'} = 1; |
| |
| if ($self->get_conf('ENABLE_ENCODING')) { |
| foreach my $quoted_command (@quoted_commands) { |
| # Directed single quotes |
| $self->{'quotes_map'}->{$quoted_command} = ["\x{2018}", "\x{2019}"]; |
| } |
| } |
| } |
| if (defined($self->get_conf('OPEN_QUOTE_SYMBOL'))) { |
| foreach my $quoted_command (@quoted_commands) { |
| $self->{'quotes_map'}->{$quoted_command}->[0] |
| = $self->get_conf('OPEN_QUOTE_SYMBOL'); |
| } |
| } |
| if (defined($self->get_conf('CLOSE_QUOTE_SYMBOL'))) { |
| foreach my $quoted_command (@quoted_commands) { |
| $self->{'quotes_map'}->{$quoted_command}->[1] |
| = $self->get_conf('CLOSE_QUOTE_SYMBOL'); |
| } |
| } |
| # some caching to avoid calling get_conf |
| $self->{'enable_encoding'} = $self->get_conf('ENABLE_ENCODING'); |
| $self->{'output_encoding_name'} = $self->get_conf('OUTPUT_ENCODING_NAME'); |
| $self->{'debug'} = $self->get_conf('DEBUG'); |
| |
| return $self; |
| } |
| |
| my %LaTeX_floats = ( |
| 'figure' => '\listoffigures', |
| 'table' => '\listoftables', |
| ); |
| |
| # associate float normalized types to latex float environment names |
| sub _prepare_floats($) |
| { |
| my $self = shift; |
| if ($self->{'floats'}) { |
| $self->{'normalized_float_latex'} = {}; |
| $self->{'latex_floats'} = {}; |
| foreach my $normalized_float_type (sort(keys(%{$self->{'floats'}}))) { |
| my $latex_variable_float_name = $normalized_float_type; |
| # note that with that transformation, some float types |
| # may be put together |
| $latex_variable_float_name =~ s/[^a-zA-z]//g; |
| if (exists($LaTeX_floats{lc($latex_variable_float_name)})) { |
| $self->{'normalized_float_latex'}->{$normalized_float_type} |
| = lc($latex_variable_float_name); |
| } else { |
| # for floats without type, and to avoid name clashes |
| my $latex_float_name = 'TexinfoFloat'.$latex_variable_float_name; |
| if (exists($self->{'latex_floats'}->{$latex_float_name})) { |
| while (exists($self->{'latex_floats'}->{$latex_float_name})) { |
| $latex_float_name .= 'a'; |
| } |
| } |
| $self->{'latex_floats'}->{$latex_float_name} |
| = $normalized_float_type; |
| $self->{'normalized_float_latex'}->{$normalized_float_type} |
| = $latex_float_name; |
| } |
| } |
| } |
| } |
| |
| sub _prepare_indices($) |
| { |
| my $self = shift; |
| |
| my $index_names = $self->{'indices_information'}; |
| if ($index_names) { |
| my $merged_index_entries |
| = Texinfo::Structuring::merge_indices($index_names); |
| # select non empty indices |
| if ($merged_index_entries) { |
| $self->{'index_entries'} = {}; |
| foreach my $index_name (keys(%{$merged_index_entries})) { |
| # print STDERR "PI $index_name\n"; |
| # print STDERR "".$merged_index_entries->{$index_name}."\n"; |
| #print STDERR " -> ".join("|", @{$merged_index_entries->{$index_name}})."\n"; |
| if (scalar(@{$merged_index_entries->{$index_name}})) { |
| $self->{'index_entries'}->{$index_name} = $merged_index_entries->{$index_name}; |
| } |
| } |
| } |
| } |
| } |
| |
| |
| sub _prepare_conversion($;$) |
| { |
| my $self = shift; |
| my $root = shift; |
| |
| # initialization for a new output |
| $self->{'page_styles'} = {}; |
| $self->{'list_environments'} = {}; |
| $self->{'description_format_commands'} = {}; |
| $self->{'style_brace_format_commands'} = {}; |
| foreach my $context (keys(%style_brace_format_command_new_commands)) { |
| $self->{'style_brace_format_commands'}->{$context} = {}; |
| } |
| $self->{'packages'} = {}; |
| $self->{'extra_definitions'} = {}; |
| $self->{'fixed_width_environments'} = {}; |
| # something different is done for the first custom heading. |
| # Not sure that values could be there, but delete anyway |
| # to be clear. |
| delete($self->{'custom_heading'}); |
| delete($self->{'index_entries'}); |
| |
| if (defined($root)) { |
| $self->_associate_other_nodes_to_sections($root); |
| } |
| |
| if ($self->{'global_commands'}->{'settitle'}) { |
| my $settitle_root = $self->{'global_commands'}->{'settitle'}; |
| if ($settitle_root->{'args'}->[0] |
| and $settitle_root->{'args'}->[0]->{'contents'} |
| and not ($settitle_root->{'extra'} |
| and $settitle_root->{'extra'}->{'missing_argument'})) { |
| $self->{'settitle_tree'} = |
| {'contents' => $settitle_root->{'args'}->[0]->{'contents'}}; |
| } |
| } |
| $self->_prepare_floats(); |
| $self->_prepare_indices(); |
| } |
| |
| sub _associate_other_nodes_to_sections($$) |
| { |
| my ($self, $root) = @_; |
| |
| # associate lone nodes with sectioning commands |
| my $additional_node_section_associations = {}; |
| |
| my $current_sectioning_command; |
| # nodes not already associated as no section has been seen, |
| # associate to the first section |
| my $pending_nodes = []; |
| |
| foreach my $element_content (@{$root->{'contents'}}) { |
| if ($element_content->{'cmdname'} |
| and $element_content->{'cmdname'} eq 'node') { |
| if (not $element_content->{'extra'}->{'associated_section'} |
| and $element_content->{'extra'}->{'normalized'}) { |
| if (defined($current_sectioning_command)) { |
| $additional_node_section_associations->{$element_content->{'extra'}->{'normalized'}} |
| = $current_sectioning_command; |
| } else { |
| push @$pending_nodes, $element_content->{'extra'}->{'normalized'}; |
| } |
| } |
| } elsif ($element_content->{'cmdname'} |
| and $root_commands{$element_content->{'cmdname'}}) { |
| $current_sectioning_command = $element_content; |
| if (scalar(@$pending_nodes)) { |
| foreach my $normalized_node_name (@$pending_nodes) { |
| $additional_node_section_associations->{$normalized_node_name} |
| = $current_sectioning_command |
| } |
| $pending_nodes = []; |
| } |
| } |
| } |
| # If there are no sectioning commands and there are nodes, |
| # $pending_nodes won't be empty and no node is associated. |
| #print STDERR "No sectioning commands but nodes\n" |
| # if (scalar(@$pending_nodes) > 0); |
| $self->{'normalized_nodes_associated_section'} |
| = $additional_node_section_associations; |
| } |
| |
| # this type marks where the \begin{document} should be, |
| # after the @-commands in preamble. It is not setup |
| # when using parse_texi_piece only. |
| my $latex_document_type = 'preamble_before_content'; |
| |
| sub output($$) |
| { |
| my ($self, $root) = @_; |
| |
| my ($output_file, $destination_directory, $output_filename) |
| = $self->determine_files_and_directory(); |
| |
| my ($encoded_destination_directory, $dir_encoding) |
| = $self->encoded_output_file_name($destination_directory); |
| my $succeeded |
| = $self->create_destination_directory($encoded_destination_directory, |
| $destination_directory); |
| return undef unless $succeeded; |
| |
| my $fh; |
| my $encoded_output_file; |
| if (! $output_file eq '') { |
| my $path_encoding; |
| ($encoded_output_file, $path_encoding) |
| = $self->encoded_output_file_name($output_file); |
| my $error_message; |
| ($fh, $error_message) = Texinfo::Common::output_files_open_out( |
| $self->output_files_information(), $self, |
| $encoded_output_file); |
| if (!$fh) { |
| $self->document_error($self, |
| sprintf(__("could not open %s for writing: %s"), |
| $output_file, $error_message)); |
| return undef; |
| } |
| } |
| |
| my $modified_root; |
| |
| # determine if there is a Top node at the end of the document |
| my $in_top_node = undef; |
| foreach my $element_content (@{$root->{'contents'}}) { |
| my $node_element; |
| if ($element_content->{'cmdname'}) { |
| my $cmdname = $element_content->{'cmdname'}; |
| if ($cmdname eq 'node') { |
| $node_element = $element_content; |
| } elsif ($cmdname eq 'part' and $element_content->{'extra'} |
| and $element_content->{'extra'}->{'part_following_node'}) { |
| $node_element = $element_content->{'extra'}->{'part_following_node'}; |
| } |
| if ($node_element or $cmdname eq 'part') { |
| if ($node_element and $node_element->{'extra'} |
| and $node_element->{'extra'}->{'normalized'} |
| and $node_element->{'extra'}->{'normalized'} eq 'Top') { |
| $in_top_node = 1; |
| } else { |
| if ($in_top_node) { |
| $in_top_node = 0; |
| last; |
| } |
| } |
| } |
| } |
| } |
| # nothing after Top node the end, mark that Top node is ignored |
| # in a container that can be used to mark that content should not |
| # be ignored anymore. |
| if ($in_top_node) { |
| $modified_root = {'contents' => [ @{$root->{'contents'}} ], 'type' => $root->{'type'}} |
| if (not defined($modified_root)); |
| push @{$modified_root->{'contents'}}, |
| {'type' => 'ignored_top_node_paragraph', 'contents' => [ |
| {'type' => 'paragraph', 'contents' => [ |
| {'text' => "\n(`Top' node ignored)\n", 'type' => 'ignored_top_node'}]}]}; |
| } |
| |
| if (not defined($modified_root)) { |
| $modified_root = $root; |
| } |
| |
| |
| $self->_prepare_conversion($modified_root); |
| |
| my $result = ''; |
| $result .= $self->_latex_begin_output(); |
| $result .= $self->convert_tree($modified_root); |
| $result .= $self->_latex_footer(); |
| |
| my $output = ''; |
| $output .= $self->write_or_return($self->_latex_header(), $fh); |
| $output .= $self->write_or_return($result, $fh); |
| |
| #print STDERR "OUTPUT fh:$fh|F:$output_file|$result"; |
| if ($fh and $output_file ne '-') { |
| Texinfo::Common::output_files_register_closed( |
| $self->output_files_information(), $encoded_output_file); |
| if (!close ($fh)) { |
| $self->document_error($self, |
| sprintf(__("error on closing %s: %s"), |
| $output_file, $!)); |
| } |
| } |
| return $output; |
| } |
| |
| # we allow the converter to already be in a context, but if |
| # not create one. |
| sub convert($$) |
| { |
| my $self = shift; |
| my $root = shift; |
| |
| $self->_prepare_conversion($root); |
| |
| my $new_context; |
| if (not exists($self->{'formatting_context'}) |
| or scalar(@{$self->{'formatting_context'}}) == 0) { |
| _push_new_context($self, 'document'); |
| $new_context = 1; |
| } |
| |
| my $result = $self->_convert($root); |
| |
| if ($new_context) { |
| _pop_context($self); |
| } |
| return $result; |
| } |
| |
| # a context should have been set by the caller |
| sub convert_tree($$) |
| { |
| my $self = shift; |
| my $root = shift; |
| |
| my $new_context; |
| if (not exists($self->{'formatting_context'}) |
| or scalar(@{$self->{'formatting_context'}}) == 0) { |
| _push_new_context($self, 'tree'); |
| $new_context = 1; |
| } |
| |
| my $result = $self->_convert($root); |
| |
| if ($new_context) { |
| _pop_context($self); |
| } |
| return $result; |
| } |
| |
| sub copy_options_for_convert_to_latex_math($) |
| { |
| my $self = shift; |
| my %options; |
| foreach my $option_name ('DEBUG', 'ENABLE_ENCODING', 'OUTPUT_ENCODING_NAME', |
| 'TEST') { |
| $options{$option_name} = $self->get_conf($option_name) |
| if (defined($self->get_conf($option_name))); |
| } |
| return %options; |
| } |
| |
| # convert texinfo tree to LaTeX math |
| # Errors are not passed, nor the converter. However the errors and warnings |
| # generated by the LaTeX conversion are few and not relevant for math tree |
| # fragments. Relevant errors should be generated when parsing the Texinfo, |
| # or when converting the final LaTeX. |
| sub convert_to_latex_math($$;$$) |
| { |
| my $self = shift; |
| my $root = shift; |
| my $options = shift; |
| my $math_style = shift; |
| |
| $math_style = 'one-line' if (not defined($math_style)); |
| |
| if (not defined($self)) { |
| $self = Texinfo::Convert::LaTeX->converter($options); |
| } |
| |
| _push_new_context($self, 'convert_to_math'); |
| |
| push @{$self->{'formatting_context'}->[-1]->{'text_context'}}, 'ctx_math'; |
| push @{$self->{'formatting_context'}->[-1]->{'math_style'}}, $math_style; |
| |
| my $result = $self->_convert($root); |
| |
| _pop_context($self); |
| |
| return $result; |
| } |
| |
| my %LaTeX_encoding_names_map = ( |
| 'utf-8' => 'utf8', |
| 'iso-8859-1' => 'latin1', |
| ); |
| |
| # book or report? |
| my $documentclass = 'book'; |
| |
| my %front_main_matter_definitions = ( |
| 'book' => {'main' => '\mainmatter', |
| 'front' => '\frontmatter'}, |
| 'report' => {'main' => '\clearpage\pagenumbering{arabic}', |
| 'front' => '\clearpage\pagenumbering{roman}'} |
| ); |
| |
| # not used as it is complicated to use section and chapter title |
| # NB this will not work any more as the \Texinfoset... macros are |
| # not used, and \pagestyle is used directly. |
| my $fancyhdr_preamble = |
| '% called when setting single headers |
| % use \nouppercase to match with Texinfo TeX style |
| \newcommand{\Texinfosetsingleheader}{\pagestyle{fancy} |
| \fancyhf{} |
| \lhead{\nouppercase{\leftmark}} |
| \rhead{\thepage} |
| } |
| |
| % called when setting double headers |
| \newcommand{\Texinfosetdoubleheader}{\pagestyle{fancy} |
| \fancyhf{} |
| \fancyhead[LE,RO]{\thepage} |
| \fancyhead[RE]{\Texinfosettitle} |
| \fancyhead[LO]{\nouppercase{\leftmark}} |
| } |
| |
| % for part and chapter, which call \thispagestyle{plain} |
| \fancypagestyle{plain}{ % |
| \fancyhf{} |
| \fancyhead[LE,RO]{\thepage} |
| } |
| |
| % match Texinfo TeX style |
| \renewcommand{\headrulewidth}{0pt}%'; |
| |
| # TODO translation |
| my $default_title = 'No Title'; |
| |
| sub _latex_header() { |
| my $self = shift; |
| # LaTeX code appearing after packages. Do it first to be able to |
| # select packages based on the code output here. |
| my $header_code = ''; |
| my $settitle; |
| if ($self->{'settitle_tree'}) { |
| $settitle = $self->convert_tree($self->{'settitle_tree'}); |
| } else { |
| $settitle = $default_title; |
| } |
| $header_code .= "\\makeatletter\n"; |
| |
| # for @thistitle and headers |
| $header_code .= "\\newcommand{\\Texinfosettitle}{$settitle}%\n"; |
| $header_code .= "\n"; |
| |
| if ($self->{'floats'}) { |
| foreach my $normalized_float_type (sort(keys(%{$self->{'normalized_float_latex'}}))) { |
| my $latex_float_name |
| = $self->{'normalized_float_latex'}->{$normalized_float_type}; |
| if (not exists($LaTeX_floats{$latex_float_name})) { |
| my $float_type = ''; |
| if ($normalized_float_type ne '') { |
| _push_new_context($self, 'float_type '.$normalized_float_type); |
| my $float = $self->{'floats'}->{$normalized_float_type}->[0]; |
| my $float_type_contents = $float->{'extra'}->{'type'}->{'content'}; |
| my $float_type = _convert($self, {'contents' => $float_type_contents}); |
| _pop_context($self); |
| } |
| my $floats_extension = $self->{'floats_extension'}; |
| $header_code .= "% new float for type `$normalized_float_type'\n"; |
| $header_code .= "\\newfloat{$latex_float_name}{htb}{$floats_extension}[chapter] |
| \\floatname{$latex_float_name}{$float_type} |
| "; |
| } |
| } |
| } |
| if ($self->{'index_entries'} |
| and scalar(keys(%{$self->{'index_entries'}}))) { |
| $header_code .= "% no index headers or page break\n"; |
| $header_code .= "\\indexsetup{level=\\relax,toclevel=section,noclearpage}%\n"; |
| |
| foreach my $index_name (sort(keys(%{$self->{'index_entries'}}))) { |
| $header_code .= "\\makeindex[name=$index_name,title=]%\n"; |
| } |
| $header_code .= "\n"; |
| } |
| # define additional commands used in @*table description format |
| foreach my $command (sort(keys(%description_command_new_commands))) { |
| if ($self->{'description_format_commands'}->{$command}) { |
| $header_code .= '% command used in \description format for '.$command."\n"; |
| $header_code .= "\\newcommand".$description_command_new_commands{$command}."%\n"; |
| $header_code .= "\n"; |
| } |
| } |
| foreach my $command_context (sort(keys(%style_brace_format_command_new_commands))) { |
| if ($self->{'style_brace_format_commands'}->{$command_context}) { |
| foreach my $command |
| (sort(keys(%{$style_brace_format_command_new_commands{$command_context}}))) { |
| if ($self->{'style_brace_format_commands'}->{$command_context}->{$command}) { |
| $header_code .= '% style command for '.$command." in '$command_context' formatting context\n"; |
| $header_code .= "\\newcommand" |
| .$style_brace_format_command_new_commands{$command_context}->{$command}."%\n"; |
| $header_code .= "\n"; |
| } |
| } |
| } |
| } |
| |
| if ($documentclass eq 'book') { |
| $header_code .= |
| '% redefine the \mainmatter command such that it does not clear page |
| % as if in double page |
| \renewcommand\mainmatter{\clearpage\@mainmattertrue\pagenumbering{arabic}} |
| '; |
| } |
| |
| $header_code .= |
| '\newenvironment{Texinfopreformatted}{% |
| \\par\\GNUTobeylines\\obeyspaces\\frenchspacing\\parskip=\\z@\\parindent=\\z@}{} |
| {\catcode`\^^M=13 \gdef\GNUTobeylines{\catcode`\^^M=13 \def^^M{\null\par}}} |
| '; |
| |
| $header_code .= |
| '\newenvironment{Texinfoindented}{\begin{list}{}{}\item\relax}{\end{list}} |
| |
| '; |
| |
| if ($self->{'packages'}->{'babel'}) { |
| $header_code .= ' |
| % this allows to select languages based on bcp47 codes. bcp47 is a superset |
| % of the LL_CC ISO 639-2 LL ISO 3166 CC information of @documentlanguage |
| \babeladjust{ |
| autoload.bcp47 = on, |
| autoload.bcp47.options = import |
| } |
| '; |
| } |
| |
| # disactivate microtype for fixed-width environments |
| if (scalar(keys(%{$self->{'fixed_width_environments'}}))) { |
| if ($self->{'packages'}->{'microtype'}) { |
| foreach my $no_microtype_environment (sort(keys(%{$self->{'fixed_width_environments'}}))) { |
| $header_code .= "\\AtBeginEnvironment{$no_microtype_environment}" |
| ."{\\microtypesetup{activate=false}}\n"; |
| } |
| } |
| $header_code .= "\n"; |
| } |
| |
| if (scalar(keys(%{$self->{'list_environments'}}))) { |
| $header_code .= "% set defaults for lists that match Texinfo TeX formatting\n"; |
| if ($self->{'list_environments'}->{'description'}) { |
| $header_code .= "\\setlist[description]{style=nextline, font=\\normalfont}\n"; |
| } |
| if ($self->{'list_environments'}->{'itemize'}) { |
| $header_code .= "\\setlist[itemize]{label=\\textbullet}\n"; |
| } |
| if ($self->{'list_environments'}->{'enumerate'}) { |
| $header_code .= "\\setlist[enumerate]{label=\\arabic*.}\n"; |
| } |
| $header_code .= "\n"; |
| } |
| $header_code .= '% used for substitutions in commands |
| \newcommand{\Texinfoplaceholder}[1]{} |
| |
| '; |
| |
| if ($self->{'page_styles'}->{'single'}) { |
| $header_code .= |
| '\newpagestyle{single}{\sethead[\chaptername{} \thechapter{} \chaptertitle{}][][\thepage] |
| {\chaptername{} \thechapter{} \chaptertitle{}}{}{\thepage}} |
| |
| '; |
| } |
| |
| if ($self->{'page_styles'}->{'double'}) { |
| $header_code .= |
| '\newpagestyle{double}{\sethead[\thepage{}][][\Texinfosettitle] |
| {\chaptername{} \thechapter{} \chaptertitle{}}{}{\thepage}} |
| |
| '; |
| } |
| |
| if ($self->{'extra_definitions'}->{'Texinfonopagebreakheading'}) { |
| $header_code .= |
| '% avoid pagebreak and headings setting for a sectioning command |
| \newcommand{\Texinfonopagebreakheading}[2]{{\let\clearpage\relax \let\cleardoublepage\relax \let\thispagestyle\Texinfoplaceholder #1{#2}}} |
| |
| '; |
| } |
| |
| if ($self->{'packages'}->{'mdframed'}) { |
| $header_code .= '% the mdframed style for @cartouche |
| \mdfdefinestyle{Texinfocartouche}{ |
| innertopmargin=10pt, innerbottommargin=10pt,% |
| roundcorner=10pt} |
| |
| '; |
| } |
| |
| if ($self->{'packages'}->{'embrac'}) { |
| # in order to have brackets and parenthese upright in slanted typewriter |
| # \textsl{\texttt, \EmbracMakeKnown{texttt} is needed. However, we only set it |
| # locally, otherwise \hyperref in \texttt can break. |
| $header_code .= '% braces are upright in italic and slanted only in @def* |
| % so it is turned off here, and turned on @def* lines |
| \EmbracOff{}% |
| |
| ' |
| } |
| |
| $header_code .= '% allow line breaking at underscore |
| \let\Texinfounderscore\_ |
| \renewcommand{\_}{\Texinfounderscore\discretionary{}{}{}} |
| '; |
| |
| # this is in order to be able to run pdflatex even |
| # if files do not exist, or filenames cannot be |
| # processed by LaTeX |
| if ($self->get_conf('TEST')) { |
| $header_code .= |
| '\renewcommand{\includegraphics}[1]{\fbox{FIG \detokenize{#1}}} |
| |
| '; |
| } |
| |
| # amsfonts for \circledR |
| # amsmath for \text in math |
| # T1 fontenc for \DH, \guillemotleft, ... |
| # eurosym for \euro |
| # textcomp for \textdegree in older LaTeX |
| # graphicx for \includegraphics |
| # needspace for \needspace. In texlive-latex-extra in debian |
| # etoolbox for \patchcmd, \ifstrempty and \AtBeginEnvironment. |
| # In texlive-latex-recommended in debian |
| # fontsize for \changefontsize. In texlive-latex-extra in debian |
| # mdframed is used for the formatting of @cartouche, |
| # microtype is used for @microtype |
| # microtype requires cm-super installed, or to use lmodern package. |
| # In texlive-latex-recommended in debian. |
| # framemethod=TikZ is needed for roundcorner. |
| # Possibility for hyperref for color: |
| # \usepackage[linkbordercolor={0 0 0}]{hyperref} |
| # titleps is used and not fancyhdr as with fancyhdr it is hard to get |
| # the section or chapter title |
| my $header = "\\documentclass{$documentclass}\n"; |
| if ($self->{'index_entries'} |
| and scalar(keys(%{$self->{'index_entries'}}))) { |
| $header .= "\\usepackage{imakeidx}\n"; |
| } |
| $header .= '\usepackage{amsfonts} |
| \usepackage{amsmath} |
| \usepackage[gen]{eurosym} |
| \usepackage[T1]{fontenc} |
| \usepackage{textcomp} |
| \usepackage{graphicx} |
| '; |
| if ($self->{'packages'}->{'needspace'}) { |
| $header .= "\\usepackage{needspace}\n"; |
| } |
| if ($self->{'packages'}->{'microtype'}) { |
| $header .= "\\usepackage[activate=false]{microtype}\n"; |
| } |
| $header .= '\usepackage{etoolbox} |
| '; |
| if ($self->{'packages'}->{'array'}) { |
| $header .= "\\usepackage{array}\n"; |
| } |
| if ($self->{'packages'}->{'embrac'}) { |
| $header .= "\\usepackage{embrac}\n"; |
| $header .= "\\usepackage{expl3}\n"; |
| } |
| if ($self->{'packages'}->{'tabularx'}) { |
| $header .= "\\usepackage{tabularx}\n"; |
| } |
| if ($self->{'packages'}->{'mdframed'}) { |
| # framemethod=tikz needed for roundcorners for @cartouche |
| $header .= "\\usepackage[framemethod=tikz]{mdframed}\n"; |
| } |
| if ($self->{'packages'}->{'fontsize'}) { |
| $header .= "\\usepackage{fontsize}\n"; |
| } |
| if (scalar(keys(%{$self->{'list_environments'}}))) { |
| $header .= "\\usepackage{enumitem}\n"; |
| } |
| if ($self->{'packages'}->{'geometry'}) { |
| $header .= "\\usepackage{geometry}\n"; |
| } |
| $header .= '\usepackage{titleps} |
| '; |
| if ($self->{'floats'}) { |
| $header .= "\\usepackage{float}\n"; |
| } |
| if ($self->{'packages'}->{'babel'}) { |
| $header .= "\\usepackage{babel}\n"; |
| } |
| $header .= '% use hidelinks to remove boxes around links to be similar to Texinfo TeX |
| \usepackage[hidelinks]{hyperref} |
| '; |
| if ($self->{'output_encoding_name'}) { |
| my $encoding = $self->{'output_encoding_name'}; |
| if (defined($LaTeX_encoding_names_map{$encoding})) { |
| $encoding = $LaTeX_encoding_names_map{$encoding}; |
| }# else { |
| # FIXME Warn? |
| #} |
| $header .= "\\usepackage[$encoding]{inputenc}\n"; |
| } |
| #if ($self->{'global_commands'}->{'shortcontents'}) { |
| # # in texlive-latex-extra in debian |
| # $header .= "\\usepackage{shorttoc}\n"; |
| #} |
| $header_code .= "\\makeatother\n"; |
| $header .= "\n"; |
| |
| return $header . $header_code; |
| } |
| |
| sub _latex_begin_output($) |
| { |
| my $self = shift; |
| |
| my $header = ''; |
| # setup defaults |
| $header .= "% set default for \@setchapternewpage\n"; |
| $header .= _set_chapter_new_page($self, 'on'); |
| $header .= "\n"; |
| # setup headings before titlepage to have no headings |
| # before titlepage. They will be set to 'on' after |
| # the titlepage if there is a titlepage |
| if (exists($self->{'global_commands'}->{'titlepage'}) |
| or exists($self->{'global_commands'}->{'shorttitlepage'})) { |
| $header .= "% no headings before titlepage\n"; |
| $header .= _set_headings($self, 'off'); |
| $header .= "\n"; |
| } |
| return $header; |
| } |
| |
| sub _begin_document($) |
| { |
| my $self = shift; |
| |
| my $result = ''; |
| $result .= '\begin{document} |
| '; |
| if (exists($self->{'global_commands'}->{'titlepage'}) |
| or exists($self->{'global_commands'}->{'shorttitlepage'})) { |
| $result .= "\n"; |
| $result .= $front_main_matter_definitions{$documentclass}->{'front'}."\n"; |
| |
| if (exists($self->{'global_commands'}->{'titlepage'})) { |
| my $element = $self->{'global_commands'}->{'titlepage'}; |
| # start a group such that the changes are forgotten when front cover is done |
| # define glues dimensions that are used in front cover formatting. |
| # Taken from Texinfo TeX. |
| # FIXME replace \\newskip by \\newlen? |
| $result .= "\\begin{titlepage}\n"; |
| $result .= "\\begingroup |
| \\newskip\\titlepagetopglue \\titlepagetopglue = 1.5in |
| \\newskip\\titlepagebottomglue \\titlepagebottomglue = 2pc |
| \\setlength{\\parindent}{0pt}\n"; |
| $result .= "% Leave some space at the very top of the page. |
| \\vglue\\titlepagetopglue\n"; |
| $self->{'titlepage_formatting'} = {'in_front_cover' => 1}; |
| _push_new_context($self, 'titlepage'); |
| $result .= $self->_convert({'contents' => $element->{'contents'}}); |
| _pop_context($self); |
| $result .= _finish_front_cover_page($self); |
| $result .= "\\end{titlepage}\n"; |
| } else { |
| my $element = $self->{'global_commands'}->{'shorttitlepage'}; |
| my $title_text = _title_font($self, $element); |
| $result .= "\\begin{titlepage}\n"; |
| $result .= "{\\raggedright $title_text}\n"; |
| # first newpage ends the title page, phantom and second newpage |
| # adds a blank page |
| $result .= "\\newpage{}\n\\phantom{blabla}\\newpage{}\n"; |
| $result .= "\\end{titlepage}\n"; |
| } |
| $result .= _set_headings($self, 'on'); |
| $result .= $front_main_matter_definitions{$documentclass}->{'main'}."\n"; |
| $self->{'titlepage_done'} = 1; |
| } |
| |
| if (exists($self->{'global_commands'}->{'contents'}) |
| and $self->{'structuring'} |
| and $self->{'structuring'}->{'sectioning_root'} |
| and not (defined($self->get_conf('CONTENTS_OUTPUT_LOCATION')) |
| and $self->get_conf('CONTENTS_OUTPUT_LOCATION') eq 'inline')) { |
| $result .= "\\tableofcontents\\newpage\n"; |
| } |
| |
| |
| return $result; |
| } |
| |
| sub _latex_footer { |
| return |
| '\end{document} |
| '; |
| } |
| |
| # all the new contexts should be created with that function |
| sub _push_new_context($$) |
| { |
| my $self = shift; |
| my $context_name = shift; |
| |
| push @{$self->{'formatting_context'}}, |
| { |
| 'code' => [0], |
| 'context_name' => $context_name, |
| 'dot_not_end_sentence' => 0, |
| 'embrac' => [], |
| 'in_quotation' => 0, |
| 'in_sectioning_command_heading' => 0, |
| 'in_skipped_node_top' => 0, |
| 'math_style' => [], |
| 'no_eol' => [], |
| 'nr_table_items_context' => [], |
| 'preformatted_context' => [], |
| # can be ctx_text, ctx_math or ctx_raw |
| 'text_context' => ['ctx_text'], |
| 'table_command_format' => [], |
| }; |
| } |
| |
| # for debug |
| sub _show_top_context_stack($) |
| { |
| my $self = shift; |
| |
| my $top_context = $self->{'formatting_context'}->[-1]; |
| my @all_keys; |
| foreach my $key (sort (keys (%$top_context))) { |
| my $key_str = $key; |
| # keep only the first letters to have something not too long |
| $key_str =~ s/(.{4}).*/$1/s; |
| my $context_item = $top_context->{$key}; |
| my $context_item_value; |
| if (not defined($context_item)) { |
| $context_item_value = 'UNDEF'; |
| } elsif (ref ($context_item) eq 'ARRAY') { |
| $context_item_value = join('|', @$context_item); |
| } else { |
| $context_item_value = $context_item; |
| } |
| push @all_keys, "$key_str:$context_item_value"; |
| } |
| return scalar(@{$self->{'formatting_context'}})." ".join('; ', @all_keys); |
| } |
| |
| sub _pop_context($) |
| { |
| my $self = shift; |
| pop @{$self->{'formatting_context'}}; |
| } |
| |
| # FIXME should $ ~ be protected? |
| sub _protect_url($$) |
| { |
| my ($self, $text) = @_; |
| |
| $text =~ s/([{}\\#%])/\\$1/g; |
| return $text; |
| } |
| |
| # in index entries !"@ have special meaning and need to be quoted with " |
| sub _protect_index_text($) |
| { |
| my $text = shift; |
| $text =~ s/([!|"@])/"$1/g; |
| |
| # if " is preceded by \ it does not quote the next character unless the |
| # \ itself is preceded by ". |
| $text =~ s/\\"/"\\"/g; |
| return $text; |
| } |
| |
| # Protect LaTeX special characters. |
| sub _protect_text($$) |
| { |
| my ($self, $text) = @_; |
| |
| if ($self->{'formatting_context'}->[-1]->{'text_context'}->[-1] eq 'ctx_math') { |
| # FIXME are there any special characters to protect in math mode, |
| # for instance # and ~? |
| } elsif ($self->{'formatting_context'}->[-1]->{'text_context'}->[-1] |
| ne 'ctx_raw') { |
| # temporarily replace \ with a control character |
| $text =~ s/\\/\x08/g; |
| |
| # replace the other special characters |
| $text =~ s/([#%&{}_\$])/\\$1/g; |
| $text =~ s/~/\\~{}/g; |
| $text =~ s/\^/\\^{}/g; |
| |
| $text =~ s/\x08/\\textbackslash{}/g; |
| |
| if ($self->{'formatting_context'}->[-1]->{'code'}->[-1]) { |
| # Prevent extra space after punctuation. (We could use \frenchspacing |
| # in the output, but this can break in section titles with hyperref.) |
| $text =~ s/([.?!:;,]) /$1\\ /g; |
| |
| # In case initial space follows punctuation from a separate element, |
| # like @code{@var{?} a}. |
| $text =~ s/^ /\\ /g; |
| |
| # Under T1 encoding there are several ligatures even in fixed width fonts |
| $text =~ s/---/{-}{-}{-}/g; |
| $text =~ s/--/{-}{-}/g; |
| $text =~ s/``/{`}{`}/g; |
| $text =~ s/''/{'}{'}/g; |
| } |
| # Disable these ligatures everywhere |
| $text =~ s/,,/{,}{,}/g; |
| $text =~ s/<</{<}{<}/g; |
| $text =~ s/>>/{>}{>}/g; |
| $text =~ s/\?`/{?}{`}/g; |
| $text =~ s/!`/{!}{`}/g; |
| |
| if ($self->{'formatting_context'}->[-1]->{'dot_not_end_sentence'}) { |
| $text =~ s/\./\.\\@/g; |
| } |
| } |
| return $text; |
| } |
| |
| sub _set_headings($$) |
| { |
| my ($self, $headings_spec) = @_; |
| |
| my $headings_type; |
| if ($headings_spec eq 'on') { |
| $headings_type = 'single'; |
| my $setchapternewpage_spec = $self->get_conf('setchapternewpage'); |
| if (defined($setchapternewpage_spec) |
| and $setchapternewpage_spec eq 'odd') { |
| $headings_type = 'double'; |
| } |
| } elsif ($headings_spec eq 'doubleafter') { |
| $headings_type = 'double'; |
| } elsif ($headings_spec eq 'singleafter') { |
| $headings_type = 'single'; |
| } elsif ($headings_spec eq 'off' or $headings_spec eq 'single' |
| or $headings_spec eq 'double') { |
| $headings_type = $headings_spec; |
| } |
| |
| if (not defined($headings_type)) { |
| confess("_set_headings no type for $headings_spec"); |
| } |
| |
| my $result = ''; |
| if ($headings_type eq 'single') { |
| $result = "\\pagestyle{single}%\n"; |
| } elsif ($headings_type eq 'double') { |
| $result = "\\pagestyle{double}%\n"; |
| } elsif ($headings_type eq 'off') { |
| $result = "\\pagestyle{empty}%\n"; |
| } |
| $self->{'page_styles'}->{$headings_type} = 1; |
| return $result; |
| } |
| |
| my %custom_headings_map = ( |
| 'everyheading' => ['head', ''], |
| 'everyfooting' => ['foot', ''], |
| 'evenheading' => ['head', 'E'], |
| 'evenfooting' => ['foot', 'E'], |
| 'oddheading', => ['head', 'O'], |
| 'oddfooting' => ['foot', 'O'], |
| ); |
| |
| # this function converts the specification to LaTex and add or |
| # replace the footing or heading specifications. |
| sub _set_custom_headings($$$) |
| { |
| my ($self, $cmdname, $headings_spec) = @_; |
| my ($head_or_foot, $page_spec) = @{$custom_headings_map{$cmdname}}; |
| |
| my $location_index = -1; |
| my @headings = ('', '', ''); |
| _push_new_context($self, 'custom_heading'); |
| foreach my $location_heading_spec (@$headings_spec) { |
| $location_index++; |
| my $heading = $self->_convert({'contents' => $location_heading_spec}); |
| $heading =~ s/^\s*//; |
| $heading =~ s/\s*$//; |
| $headings[$location_index] = $heading; |
| } |
| _pop_context($self); |
| |
| my @replaced_specs; |
| if ($page_spec eq '') { |
| @replaced_specs = ('E', 'O'); |
| } else { |
| @replaced_specs = ($page_spec); |
| } |
| my $first_custom_heading; |
| if (not exists($self->{'custom_heading'})) { |
| $first_custom_heading = 1; |
| $self->{'custom_heading'} = {$head_or_foot => {}}; |
| } elsif (!exists($self->{'custom_heading'}->{$head_or_foot})) { |
| $self->{'custom_heading'}->{$head_or_foot} = {}; |
| } |
| foreach my $spec (@replaced_specs) { |
| $self->{'custom_heading'}->{$head_or_foot}->{$spec} = \@headings; |
| } |
| return _format_heading_command($self, $first_custom_heading); |
| } |
| |
| my @head_foot_order = ('head', 'foot'); |
| my @even_odd_order = (['E', 'bracket'], ['O', 'brace']); |
| sub _format_heading_command($$) |
| { |
| my $self = shift; |
| my $first_custom_heading = shift; |
| |
| my $result = ''; |
| if ($first_custom_heading) { |
| $result .= "\\newpagestyle{custom}{%\n"; |
| } else { |
| $result .= "\\renewpagestyle{custom}{%\n"; |
| } |
| foreach my $head_or_foot (@head_foot_order) { |
| if (exists($self->{'custom_heading'}->{$head_or_foot})) { |
| my $head_or_foot_spec = $self->{'custom_heading'}->{$head_or_foot}; |
| $result .= '\set' . $head_or_foot; |
| foreach my $even_odd_and_separator (@even_odd_order) { |
| my ($even_or_odd, $separator) = @{$even_odd_and_separator}; |
| my $headings; |
| if (exists($head_or_foot_spec->{$even_or_odd})) { |
| $headings = $head_or_foot_spec->{$even_or_odd}; |
| } else { |
| $headings = ['', '', '']; |
| } |
| foreach my $heading (@{$headings}) { |
| if ($separator eq 'bracket') { |
| $result .= '['.$heading.']'; |
| } else { |
| $result .= '{'.$heading.'}'; |
| } |
| } |
| $result .= "%\n"; |
| } |
| } |
| } |
| $result .= "}%\n"; |
| $result .= "\\pagestyle{custom}%\n"; |
| return $result; |
| } |
| |
| |
| # to change the chapter we substitute in the \chapter command. |
| # REMARK it is fragile as it depends on the LaTeX codes. It is also |
| # most probably specific of the documentclass. It is present in both |
| # report and book document classes in 2021 |
| my $odd_chapter_new_page_code = '\if@openright\cleardoublepage\else\clearpage\fi'; |
| my $default_chapter_page_code = $odd_chapter_new_page_code; |
| # To make sure that we substitute the right code, we add a |
| # distinctive code that does nothing. This is needed when |
| # code is simply removed or when simple code is substituted. |
| my $chapter_new_page_marking_placeholder |
| = '\Texinfoplaceholder{setchapternewpage placeholder}'; |
| |
| my %setchapternewpage_new_page_spec_code = ( |
| 'on' => $chapter_new_page_marking_placeholder.'\clearpage', |
| 'off' => $chapter_new_page_marking_placeholder.'', |
| 'odd' => $odd_chapter_new_page_code, |
| ); |
| |
| # Note that the code should probably be different if the default code |
| # wes not distinctive enough |
| sub _set_chapter_new_page($$) |
| { |
| my ($self, $setchapternewpage_spec) = @_; |
| |
| my $substituted_code; |
| if (defined($self->{'prev_chapter_new_page_substitution'})) { |
| $substituted_code = $self->{'prev_chapter_new_page_substitution'}; |
| } else { |
| $substituted_code = $default_chapter_page_code; |
| } |
| my $new_code = $setchapternewpage_new_page_spec_code{$setchapternewpage_spec}; |
| |
| my $result = ''; |
| # do not substitute if it is the same, for instance |
| # if setting the same as document class default or setting twice |
| if ($new_code ne $substituted_code) { |
| $result .= '\makeatletter |
| \patchcmd{\chapter}{'.$substituted_code.'}{'.$new_code.'}{}{} |
| \makeatother |
| '; |
| } |
| |
| # reset headings after titlepage only, or immediately |
| # if there is no titlepage |
| if ((not $self->{'global_commands'}->{'titlepage'} |
| and not $self->{'global_commands'}->{'shorttitlepage'}) |
| or $self->{'titlepage_done'}) { |
| $result .= _set_headings($self, 'on'); |
| } |
| |
| $self->{'prev_chapter_new_page_substitution'} = $new_code; |
| |
| return $result; |
| } |
| |
| my %small_font_preformatted_commands; |
| foreach my $small_font_preformatted_command ( |
| grep {/^small/} keys(%preformatted_commands)) { |
| $small_font_preformatted_commands{$small_font_preformatted_command} = 1; |
| } |
| |
| sub _open_preformatted($$) |
| { |
| my $self = shift; |
| my $element = shift; |
| |
| my $command = $self->{'formatting_context'}->[-1]->{'preformatted_context'}->[-1]; |
| |
| if ($preformatted_code_commands{$command}) { |
| push @{$self->{'formatting_context'}->[-1]->{'code'}}, 1; |
| } |
| |
| my $result = ''; |
| $result .= '\\begin{Texinfopreformatted}%'."\n"; |
| $self->{'fixed_width_environments'}->{'Texinfopreformatted'} = 1; |
| # The % comments out the newline to avoid extra vertical space. |
| |
| if ($preformatted_code_commands{$command}) { |
| $result .= '\\ttfamily '; |
| } |
| if ($small_font_preformatted_commands{$command}) { |
| $result .= "\\$small_font_size "; |
| } |
| return $result; |
| } |
| |
| sub _close_preformatted($$) |
| { |
| my $self = shift; |
| my $element = shift; |
| |
| my $command = $self->{'formatting_context'}->[-1]->{'preformatted_context'}->[-1]; |
| if ($preformatted_code_commands{$command}) { |
| pop @{$self->{'formatting_context'}->[-1]->{'code'}}; |
| } |
| return '\\end{Texinfopreformatted}'."\n"; |
| } |
| |
| sub _open_preformatted_command($$) |
| { |
| my $self = shift; |
| my $command = shift; |
| |
| push @{$self->{'formatting_context'}->[-1]->{'preformatted_context'}}, $command; |
| return ''; |
| } |
| |
| sub _close_preformatted_command($$) |
| { |
| my $self = shift; |
| my $command = shift; |
| |
| my $old_context = pop @{$self->{'formatting_context'}->[-1]->{'preformatted_context'}}; |
| die if ($old_context ne $command); |
| return ''; |
| } |
| |
| sub _open_preformatted_stack($$) |
| { |
| my $self = shift; |
| my $stack = shift; |
| |
| my $result = ''; |
| foreach my $preformatted_command (@$stack) { |
| $result .= _open_preformatted_command($self, $preformatted_command); |
| } |
| return $result; |
| } |
| |
| sub _close_preformatted_stack($$) |
| { |
| my $self = shift; |
| my $stack = shift; |
| |
| my $result = ''; |
| foreach my $preformatted_command (reverse @$stack) { |
| $result .= _close_preformatted_command($self, $preformatted_command); |
| } |
| return $result; |
| } |
| |
| sub _title_font($$) |
| { |
| my $self = shift; |
| my $element = shift; |
| |
| if ($element->{'args'}->[0] and $element->{'args'}->[0]->{'contents'}) { |
| # in Texinfo TeX seems a bit smaller, but LARGE seems too small |
| my $result = "{\\huge \\bfseries "; |
| $result .= _convert($self, {'contents' => $element->{'args'}->[0]->{'contents'}}); |
| $result .= '}'; |
| return $result; |
| } |
| return ''; |
| } |
| |
| sub _set_environment_options($$$) |
| { |
| my $self = shift; |
| my $command = shift; |
| my $element = shift; |
| |
| if (exists($LaTeX_environment_options{$command})) { |
| return $LaTeX_environment_options{$command}; |
| } |
| |
| if ($command eq 'enumerate') { |
| my $environment = $LaTeX_environment_commands{$command}[0]; |
| if ($element->{'extra'} and |
| exists($element->{'extra'}->{'enumerate_specification'})) { |
| my $specification = $element->{'extra'}->{'enumerate_specification'}; |
| if ($specification eq 'a') { |
| return {$environment => 'label=\alph*.'}; |
| } elsif ($specification eq 'A') { |
| return {$environment => 'label=\Alph*.'}; |
| } |
| if ($specification =~ /^[a-z]+$/) { |
| return {$environment |
| => 'label=\alph*.,start='.(ord($specification) - ord('a') + 1)}; |
| } elsif ($specification =~ /^[A-Z]+$/) { |
| return {$environment |
| => 'label=\Alph*.,start='.(ord($specification) - ord('A') + 1)}; |
| } else { |
| return {$environment => "start=$specification"}; |
| } |
| } |
| } elsif ($command eq 'itemize') { |
| my $environment = $LaTeX_environment_commands{$command}[0]; |
| if ($element->{'extra'} and $element->{'extra'}->{'command_as_argument'} |
| and $element->{'extra'}->{'command_as_argument'}->{'cmdname'} eq 'w') { |
| # the result with \hbox{} would probably have been the same, |
| # but using an empty label is more consistent with the Texinfo manual |
| return {$environment => 'label={}'}; |
| } elsif ($element->{'args'} and $element->{'args'}->[0]->{'contents'}) { |
| # NOTE when @itemize is in a preformatted environment (@example...), |
| # we are not in a preformatted type here, such that the conversion |
| # does not take into account the preformatted environment. Ok or best. |
| my $itemize_label = _convert($self, $element->{'args'}->[0]); |
| if ($itemize_label ne '') { |
| return {$environment => 'label='.$itemize_label}; |
| } |
| } |
| } |
| return undef; |
| } |
| |
| sub _xtable_description_command_format($$) |
| { |
| my $self = shift; |
| my $element = shift; |
| |
| if ($element->{'extra'} |
| and $element->{'extra'}->{'command_as_argument'}) { |
| my $command_as_argument |
| = $element->{'extra'}->{'command_as_argument'}->{'cmdname'}; |
| $command_as_argument = 'code' if ($command_as_argument eq 'kbd' |
| and _kbd_code_style($self)); |
| if (exists($description_command_format{$command_as_argument}) |
| and $description_command_format{$command_as_argument} ne '') { |
| # gather for outputting in the preamble if associated to a new command |
| if (exists($description_command_new_commands{$command_as_argument})) { |
| $self->{'description_format_commands'}->{$command_as_argument} = 1; |
| } elsif ($style_brace_format_command_new_commands{'cmd_text'}->{$command_as_argument}) { |
| $self->{'style_brace_format_commands'}->{'cmd_text'} |
| ->{$command_as_argument} = 1; |
| } |
| return $description_command_format{$command_as_argument} |
| } |
| } |
| return undef; |
| } |
| |
| sub _kbd_code_style($) |
| { |
| my $self = shift; |
| my $kbdinputstyle = $self->get_conf('kbdinputstyle'); |
| return (defined($kbdinputstyle) |
| and ($kbdinputstyle eq 'code' |
| or ($kbdinputstyle eq 'example' |
| and (not (scalar(@{$self->{'formatting_context'}->[-1]->{'preformatted_context'}}) |
| and $preformatted_code_commands{$self->{'formatting_context'}->[-1]->{'preformatted_context'}->[-1]}))))); |
| } |
| |
| sub _finish_front_cover_page($) |
| { |
| my $self = shift; |
| my $result = ''; |
| if ($self->{'titlepage_formatting'} |
| and $self->{'titlepage_formatting'}->{'in_front_cover'}) { |
| # add a rule if there was a @title (same as in Texinfo TeX) |
| if ($self->{'titlepage_formatting'}->{'title'}) { |
| delete $self->{'titlepage_formatting'}->{'title'}; |
| $result .= '\vskip4pt \hrule height 2pt width \hsize |
| \vskip\titlepagebottomglue |
| '; |
| } |
| $result .= "\\endgroup\n"; |
| $self->{'titlepage_formatting'}->{'in_front_cover'} = 0; |
| } |
| return $result; |
| } |
| |
| sub _tree_anchor_label { |
| my $node_content = shift; |
| |
| my $label = Texinfo::Convert::NodeNameNormalization::normalize_node |
| ({'contents' => $node_content}); |
| return "anchor:$label"; |
| } |
| |
| my %LaTeX_see_index_commands_text = ( |
| 'seeentry' => 'see', |
| 'seealso' => 'seealso' |
| ); |
| |
| sub _index_entry($$) |
| { |
| my $self = shift; |
| my $element = shift; |
| if ($element->{'extra'} and $element->{'extra'}->{'index_entry'}) { |
| my $entry = $element->{'extra'}->{'index_entry'}; |
| my $entry_index_name = $entry->{'index_name'}; |
| my $index_name = $entry_index_name; |
| if ($self->{'indices_information'}->{$entry_index_name}->{'merged_in'}) { |
| $index_name |
| = $self->{'indices_information'}->{$entry_index_name}->{'merged_in'}; |
| } |
| my $in_code = 0; |
| if ($self->{'indices_information'}->{$entry_index_name}->{'in_code'}) { |
| $in_code = 1; |
| } |
| my $options |
| = Texinfo::Structuring::setup_index_entry_keys_formatting($self); |
| my $current_entry = $element; |
| my $current_sortas; |
| my $subentry_commands = [$element]; |
| if (exists($element->{'extra'}->{'sortas'})) { |
| $current_sortas = $element->{'extra'}->{'sortas'}; |
| } |
| my $subentries = [[{'contents' => $entry->{'content_normalized'}}, |
| $current_sortas]]; |
| while ($current_entry->{'extra'} |
| and $current_entry->{'extra'}->{'subentry'}) { |
| $current_entry = $current_entry->{'extra'}->{'subentry'}; |
| my $current_sortas; |
| if (exists($current_entry->{'extra'}->{'sortas'})) { |
| $current_sortas = $current_entry->{'extra'}->{'sortas'}; |
| } |
| push @$subentries, [$current_entry->{'args'}->[0], $current_sortas]; |
| push @$subentry_commands, $current_entry; |
| } |
| _push_new_context($self, 'index_entry'); |
| $self->{'formatting_context'}->[-1]->{'index'} = 1; |
| my @result; |
| foreach my $subentry_entry_and_sortas (@$subentries) { |
| my $sortas; |
| my ($subentry, $subentry_sortas) = @$subentry_entry_and_sortas; |
| if ($in_code) { |
| push @{$self->{'formatting_context'}->[-1]->{'code'}}, 1; |
| } |
| my $index_entry = _convert($self, $subentry); |
| if ($in_code) { |
| pop @{$self->{'formatting_context'}->[-1]->{'code'}}; |
| } |
| # always setup a string to sort with as we may use commands |
| $sortas = Texinfo::Structuring::index_entry_sort_string($entry, |
| $subentry, $subentry_sortas, $options); |
| my $result = ''; |
| if (defined($sortas)) { |
| # | in sort key breaks with hyperref |
| $sortas =~ s/\|//g; |
| $result = _protect_text($self, $sortas); |
| $result =~ s/\\[{}]//g; # cannot have unmatched braces in index entry |
| $result = _protect_index_text($result).'@'; |
| } |
| if ($in_code) { |
| $result .= "\\texttt{" . _protect_index_text($index_entry) . "}"; |
| } else { |
| $result .= _protect_index_text($index_entry); |
| } |
| push @result, $result; |
| } |
| my $seeresult = ''; |
| SEEENTRY: |
| foreach my $subentry_command (@$subentry_commands) { |
| foreach my $seecommand (('seeentry', 'seealso')) { |
| if ($subentry_command->{'extra'}->{$seecommand} |
| and $subentry_command->{'extra'}->{$seecommand}->{'args'}->[0]) { |
| my $seeconverted = _convert($self, |
| $subentry_command->{'extra'}->{$seecommand}->{'args'}->[0]); |
| $seeresult = '|'.$LaTeX_see_index_commands_text{$seecommand}.'{' |
| .$seeconverted.'}'; |
| last SEEENTRY; |
| } |
| } |
| } |
| _pop_context($self); |
| return "\\index[$index_name]{".join('!',@result).$seeresult."}%\n"; |
| } |
| return ''; |
| } |
| |
| # turn off embrac for an opening @-command |
| sub _stop_embrac |
| { |
| my $self = shift; |
| my $result = shift; |
| my $did_stop_embrac = 0; |
| |
| if ($self->{'formatting_context'}->[-1]->{'embrac'} |
| and $self->{'formatting_context'}->[-1]->{'embrac'}->[-1] |
| and $self->{'formatting_context'}->[-1]->{'embrac'}->[-1]->{'status'} == 1) { |
| $result .= '\EmbracOff{}'; |
| $self->{'formatting_context'}->[-1]->{'embrac'}->[-1]->{'status'} = 0; |
| $did_stop_embrac = 1; |
| } |
| return ($result, $did_stop_embrac) |
| } |
| |
| # turn on embrac, should be after closing an @-command that lead |
| # to turning off embrac |
| sub _restart_embrac_if_needed |
| { |
| my $self = shift; |
| my $result = shift; |
| my $did_stop_embrac = shift; |
| |
| if ($did_stop_embrac) { |
| $self->{'formatting_context'}->[-1]->{'embrac'}->[-1]->{'status'} = 1; |
| $result .= '\EmbracOn{}'; |
| } |
| return $result; |
| } |
| |
| sub _convert($$); |
| |
| # Convert the Texinfo tree under $ELEMENT |
| sub _convert($$) |
| { |
| my ($self, $element) = @_; |
| |
| if ($self->{'debug'}) { |
| print STDERR "CONVLTX ".Texinfo::Common::debug_print_element_short($element)."\n"; |
| if ($self->{'debug'} > 4) { |
| print STDERR " CTX "._show_top_context_stack($self)."\n"; |
| } |
| } |
| |
| my $type = $element->{'type'}; |
| my $cmdname = $element->{'cmdname'}; |
| |
| if ((defined($type) and $self->{'ignored_types'}->{$type}) |
| or (defined($cmdname) |
| and ($self->{'ignored_commands'}->{$cmdname} |
| or ($Texinfo::Commands::brace_commands{$cmdname} |
| and $Texinfo::Commands::brace_commands{$cmdname} eq 'inline' |
| and $cmdname ne 'inlinefmtifelse' |
| and (($inline_format_commands{$cmdname} |
| and (!$element->{'extra'}->{'format'} |
| or !$self->{'expanded_formats_hash'}->{$element->{'extra'}->{'format'}})) |
| or (!$inline_format_commands{$cmdname} |
| and !defined($element->{'extra'}->{'expand_index'}))))))) { |
| return ''; |
| } |
| my $result = ''; |
| |
| if ($self->{'formatting_context'}->[-1]->{'in_skipped_node_top'}) { |
| my $node_element; |
| if (defined($cmdname) and $cmdname eq 'node') { |
| $node_element = $element; |
| } elsif (defined($cmdname) and $cmdname eq 'part' and $element->{'extra'} |
| and $element->{'extra'}->{'part_following_node'}) { |
| $node_element = $element->{'extra'}->{'part_following_node'}; |
| } |
| if (($node_element |
| and not ($node_element->{'extra'} |
| and $node_element->{'extra'}->{'normalized'} |
| and $node_element->{'extra'}->{'normalized'} eq 'Top')) |
| or (defined($type) and $type eq 'ignored_top_node_paragraph') |
| or (defined($cmdname) and $cmdname eq 'part')) { |
| $self->{'formatting_context'}->[-1]->{'in_skipped_node_top'} = 0; |
| } elsif (not ((defined($cmdname) |
| and ($informative_commands{$cmdname} |
| or $sectioning_heading_commands{$cmdname} |
| or $cmdname eq 'float' |
| or $cmdname eq 'anchor')) |
| or ($type and $type eq 'paragraph'))) { |
| return ''; |
| } |
| } |
| |
| # in ignorable spaces, keep only form feeds. |
| if ($type and $self->{'ignorable_space_types'}->{$type}) { |
| if ($type eq 'spaces_after_close_brace') { |
| if ($element->{'text'} =~ /\f/) { |
| $result = '\par{}'; |
| } |
| } |
| return $result; |
| } |
| |
| if ($type and ($type eq 'empty_line')) { |
| if ($element->{'text'} =~ /\f/) { |
| $result = '\par{}'; |
| } |
| return $result."\n"; |
| } |
| |
| # process text |
| if (defined($element->{'text'})) { |
| if (!$type or $type ne 'untranslated') { |
| my $result = _protect_text($self, $element->{'text'}); |
| return $result; |
| } else { |
| my $tree = $self->gdt($element->{'text'}); |
| my $converted = _convert($self, $tree); |
| return $converted; |
| } |
| } |
| |
| if ($element->{'extra'}) { |
| if ($element->{'extra'}->{'missing_argument'} |
| and (!$element->{'contents'} or !@{$element->{'contents'}})) { |
| return ''; |
| } |
| } |
| |
| # for displaymath that closes the preformatted |
| my $preformatted_to_reopen; |
| if ($cmdname) { |
| my $unknown_command; |
| my $command_format_context = 'cmd_text'; |
| if ($self->{'formatting_context'}->[-1]->{'text_context'}->[-1] eq 'ctx_math') { |
| $command_format_context = 'cmd_math'; |
| } |
| my $did_stop_embrac; |
| if (defined($nobrace_symbol_text{$cmdname})) { |
| if ($cmdname eq ':') { |
| if ($command_format_context ne 'cmd_math') { |
| $result .= "\\\@"; |
| } |
| } elsif ($cmdname eq '*') { |
| if ($command_format_context ne 'cmd_math') { |
| if ($self->{'formatting_context'}->[-1]->{'no_eol'} |
| and $self->{'formatting_context'}->[-1]->{'no_eol'}->[-1]) { |
| # in tabularx in @def* we ignore @* |
| $result = ' '; |
| } else { |
| # FIXME \leavevmode{} is added to avoid |
| # ! LaTeX Error: There's no line here to end. |
| # but it is not clearly correct |
| $result = "\\leavevmode{}\\\\"; |
| #$result = "\\linebreak[4]\n"; |
| } |
| } else { |
| if ($self->{'formatting_context'}->[-1]->{'math_style'}->[-1] |
| eq 'one-line') { |
| $result .= ""; |
| } else { |
| # no such case for now, but could be in the future |
| $result .= "\\\\"; |
| } |
| } |
| } elsif ($cmdname eq '.' or $cmdname eq '?' or $cmdname eq '!') { |
| if ($command_format_context ne 'cmd_math') { |
| $result .= "\\\@"; |
| } |
| $result .= $cmdname; |
| } elsif ($cmdname eq ' ' or $cmdname eq "\n" or $cmdname eq "\t") { |
| $result .= "\\ {}"; |
| } elsif ($cmdname eq '-') { |
| $result .= "\\-{}"; |
| |
| } elsif ($cmdname eq '{' or $cmdname eq '}') { |
| # Index entries need balanced braces so we can't use \{ and \}. |
| if ($self->{'formatting_context'}->[-1]->{'index'}) { |
| if ($cmdname eq '{') { |
| if ($self->{'formatting_context'}->[-1]->{'text_context'}->[-1] |
| eq 'ctx_math') { |
| $result .= '\\lbrace{}'; |
| } else { |
| $result .= '\\textbraceleft{}'; |
| } |
| } elsif ($cmdname eq '}') { |
| if ($self->{'formatting_context'}->[-1]->{'text_context'}->[-1] |
| eq 'ctx_math') { |
| $result .= '\\rbrace{}'; |
| } else { |
| $result .= '\\textbraceright{}'; |
| } |
| } |
| } else { |
| # always protect, even in math mode |
| $result .= "\\$cmdname"; |
| } |
| } elsif ($cmdname eq '\\' |
| and $self->{'formatting_context'}->[-1]->{'text_context'}->[-1] |
| eq 'ctx_math') { |
| $result .= '\\backslash{}'; |
| } else { |
| $result .= _protect_text($self, $nobrace_symbol_text{$cmdname}); |
| } |
| return $result; |
| } elsif (exists($brace_no_arg_commands{$cmdname})) { |
| my $converted_command = $cmdname; |
| if ($cmdname eq 'click' and $element->{'extra'} |
| and exists($element->{'extra'}->{'clickstyle'})) { |
| $converted_command = $element->{'extra'}->{'clickstyle'}; |
| } |
| if ($self->{'enable_encoding'}) { |
| my $encoding = $self->{'output_encoding_name'}; |
| if ($letter_no_arg_commands{$converted_command}) { |
| my $conversion |
| = Texinfo::Convert::Unicode::brace_no_arg_command($converted_command, |
| $encoding); |
| if (defined($conversion)) { |
| $result .= $conversion; |
| return $result; |
| } |
| } |
| } |
| if (exists($LaTeX_no_arg_brace_commands{$command_format_context}->{$converted_command})) { |
| if ($converted_command eq 'error' |
| and $self->{'formatting_context'}->[-1]->{'in_sectioning_command_heading'}) { |
| # in a sectioning command, the contents bookmark is also generated, and |
| # some commands do not play well with the contents bookmark. In particular |
| # \fbox. \texorpdfstring allows to specify a different output for |
| # the string in contents bookmark. |
| # |
| # TODO Note that other commands than @error are not perfect in contents |
| # bookmarks, in particular all the commands formatted in math disappear. |
| # However the other commands have no clear string representations, |
| # being removed in the contents bookmark strings is not so bad until |
| # a better solution is found |
| # |
| # See also |
| # https://github.com/latex3/hyperref/issues/207#issuecomment-920712424 |
| $result .= '\texorpdfstring{'. |
| $LaTeX_no_arg_brace_commands{$command_format_context}->{$converted_command} |
| # FIXME translation |
| .'}{error}' |
| } else { |
| $result .= $LaTeX_no_arg_brace_commands{$command_format_context}->{$converted_command}; |
| } |
| } else { |
| die "BUG: unknown brace_no_arg_commands $cmdname $converted_command\n"; |
| } |
| return $result; |
| # commands with braces |
| } elsif ($accent_commands{$cmdname}) { |
| if ($self->{'enable_encoding'}) { |
| my $encoding = $self->{'output_encoding_name'}; |
| my $sc; |
| my $accented_text |
| = Texinfo::Convert::Text::text_accents($element, $encoding, $sc); |
| $result .= _protect_text($self, $accented_text); |
| } else { |
| my $accent_arg = ''; |
| |
| if ($LaTeX_accent_commands{$command_format_context}->{$cmdname}) { |
| $result .= "\\$LaTeX_accent_commands{$command_format_context}->{$cmdname}\{"; |
| if ($element->{'args'}) { |
| $accent_arg = _convert($self, $element->{'args'}->[0]); |
| } |
| $result .= $accent_arg; |
| $result .= '}'; |
| } elsif ($cmdname eq 'dotless') { |
| if ($element->{'args'}) { |
| $accent_arg = _convert($self, $element->{'args'}->[0]); |
| } |
| if ($accent_arg eq 'i' or $accent_arg eq 'j') { |
| if ($command_format_context eq 'cmd_math') { |
| $result .= "\\${accent_arg}math{}"; |
| } else { |
| $result .= "\\${accent_arg}{}"; |
| } |
| } else { |
| # should be an error, but we do not care, it is better if it is |
| # handled during parsing |
| $result .= _protect_text($self, $accent_arg); |
| } |
| return $result; |
| # accent without math mode command, use slanted text |
| } elsif ($command_format_context eq 'cmd_math' |
| and $LaTeX_accent_commands{'cmd_text'}->{$cmdname}) { |
| $result .= "\\textsl{\\$LaTeX_accent_commands{'cmd_text'}->{$cmdname}\{"; |
| # we do not want accents within to be math accents |
| if ($element->{'args'}) { |
| push @{$self->{'formatting_context'}->[-1]->{'text_context'}}, 'ctx_text'; |
| $accent_arg = _convert($self, $element->{'args'}->[0]); |
| my $old_context |
| = pop @{$self->{'formatting_context'}->[-1]->{'text_context'}}; |
| } |
| $result .= $accent_arg; |
| $result .= '}}'; |
| } |
| } |
| return $result; |
| } elsif (exists($LaTeX_style_brace_commands{'cmd_text'}->{$cmdname}) |
| or ($element->{'type'} |
| and $element->{'type'} eq 'definfoenclose_command')) { |
| my $did_stop_embrac = 0; |
| ($result, $did_stop_embrac) = _stop_embrac($self, $result) |
| if ($cmdname eq 'r'); |
| my $formatted_cmdname; |
| if ($cmdname eq 'kbd' and _kbd_code_style($self)) { |
| # use code for kbd formatting if needed |
| $formatted_cmdname = 'code'; |
| } else { |
| $formatted_cmdname = $cmdname; |
| } |
| if ($brace_code_commands{$cmdname}) { |
| push @{$self->{'formatting_context'}->[-1]->{'code'}}, 1; |
| } elsif ($roman_style_commands{$cmdname}) { |
| push @{$self->{'formatting_context'}->[-1]->{'code'}}, 0; |
| } |
| if ($self->{'quotes_map'}->{$formatted_cmdname}) { |
| $result .= $self->{'quotes_map'}->{$formatted_cmdname}->[0]; |
| } |
| my $command_format_context = $command_format_context; |
| # gather for outputting in the preamble if associated to a new command |
| if ($style_brace_format_command_new_commands{$command_format_context} |
| ->{$formatted_cmdname}) { |
| $self->{'style_brace_format_commands'}->{$command_format_context} |
| ->{$formatted_cmdname} = 1; |
| } |
| if ($LaTeX_style_brace_commands{$command_format_context}->{$formatted_cmdname}) { |
| my $LaTeX_style_command |
| = $LaTeX_style_brace_commands{$command_format_context}->{$formatted_cmdname}; |
| if ($need_known_embrac{$LaTeX_style_command} |
| and $self->{'formatting_context'}->[-1]->{'embrac'} |
| and $self->{'formatting_context'}->[-1]->{'embrac'}->[-1] |
| and $self->{'formatting_context'}->[-1]->{'embrac'}->[-1]->{'status'} == 1) { |
| my $defined_style_embrac = $need_known_embrac{$LaTeX_style_command}; |
| if (not $self->{'formatting_context'}->[-1]->{'embrac'}->[-1] |
| ->{'made_known'}->{$defined_style_embrac}) { |
| $self->{'formatting_context'}->[-1]->{'embrac'}->[-1] |
| ->{'made_known'}->{$defined_style_embrac} = 1; |
| } |
| } |
| $result .= "$LaTeX_style_command\{"; |
| } |
| if ($element->{'args'}) { |
| $result .= _convert($self, $element->{'args'}->[0]); |
| } |
| if ($LaTeX_style_brace_commands{$command_format_context}->{$formatted_cmdname}) { |
| $result .= '}'; |
| } |
| if ($self->{'quotes_map'}->{$formatted_cmdname}) { |
| $result .= $self->{'quotes_map'}->{$formatted_cmdname}->[1]; |
| } |
| if ($brace_code_commands{$cmdname}) { |
| pop @{$self->{'formatting_context'}->[-1]->{'code'}}; |
| } elsif ($roman_style_commands{$cmdname}) { |
| pop @{$self->{'formatting_context'}->[-1]->{'code'}}; |
| } |
| $result = _restart_embrac_if_needed($self, $result, $did_stop_embrac); |
| return $result; |
| } elsif ($cmdname eq 'dmn') { |
| $result .= '\\thinspace '; |
| if ($element->{'args'}) { |
| $result .= _convert($self, $element->{'args'}->[0]); |
| } |
| } elsif ($cmdname eq 'verb') { |
| # NOTE \verb is forbidden in other macros in LaTeX. We do |
| # not enforce this constraint here, nor warn. Checking |
| # whether we are in another LaTeX macro would probably be a pain. |
| # It should be ok, though, as it is described as an error in the manual: |
| # It is not reliable to use @verb inside other Texinfo constructs |
| $result .= "\\verb" .$element->{'extra'}->{'delimiter'}; |
| push @{$self->{'formatting_context'}->[-1]->{'text_context'}}, 'ctx_raw'; |
| if ($element->{'args'}) { |
| $result .= _convert($self, $element->{'args'}->[0]); |
| } |
| my $old_context = pop @{$self->{'formatting_context'}->[-1]->{'text_context'}}; |
| die if ($old_context ne 'ctx_raw'); |
| $result .= $element->{'extra'}->{'delimiter'}; |
| return $result; |
| } elsif ($cmdname eq 'image') { |
| if (defined($element->{'args'}->[0]) |
| and $element->{'args'}->[0]->{'contents'} |
| and @{$element->{'args'}->[0]->{'contents'}}) { |
| # distinguish text basefile used to find the file and |
| # converted basefile with special characters escaped |
| my $basefile = Texinfo::Convert::Text::convert_to_text( |
| {'contents' => $element->{'args'}->[0]->{'contents'}}, |
| {'code' => 1, %{$self->{'convert_text_options'}}}); |
| |
| # warn if no file is found, even though the basefile is used |
| # in any case. |
| my $image_file_found; |
| foreach my $extension (@LaTeX_image_extensions) { |
| my ($file_name, $file_name_encoding) |
| = $self->encoded_input_file_name("$basefile.$extension"); |
| my $located_file = |
| $self->Texinfo::Common::locate_include_file($file_name); |
| if (defined($located_file)) { |
| $image_file_found = 1; |
| last; |
| } |
| } |
| if (not $image_file_found) { |
| $self->line_warn($self, |
| sprintf(__("\@image file `%s' (for LaTeX) not found"), |
| $basefile), |
| $element->{'source_info'}); |
| } |
| # Use the basename and not the file found. It is agreed that it is |
| # better, since in any case the files are moved. |
| # If the file path found was to be used it should be decoded to perl |
| # codepoints too. |
| # using basefile with escaped characters, no extension to let LaTeX |
| # choose the extension |
| # FIXME not clear at all what can be in filenames here, |
| # what should be escaped and how |
| my $converted_basefile = $basefile; |
| # for now minimal protection. Not sure that % is problematic |
| $converted_basefile =~ s/([%{}\\])/\\$1/g; |
| my $image_file = $converted_basefile; |
| my $width; |
| if ((@{$element->{'args'}} >= 2) |
| and defined($element->{'args'}->[1]) |
| and $element->{'args'}->[1]->{'contents'} |
| and @{$element->{'args'}->[1]->{'contents'}}){ |
| push @{$self->{'formatting_context'}->[-1]->{'text_context'}}, 'ctx_raw'; |
| $width = _convert($self, {'contents' |
| => $element->{'args'}->[1]->{'contents'}}); |
| my $old_context = pop @{$self->{'formatting_context'}->[-1]->{'text_context'}}; |
| die if ($old_context ne 'ctx_raw'); |
| if ($width !~ /\S/) { |
| $width = undef; |
| } |
| } |
| my $height; |
| if ((@{$element->{'args'}} >= 3) |
| and defined($element->{'args'}->[2]) |
| and $element->{'args'}->[2]->{'contents'} |
| and @{$element->{'args'}->[2]->{'contents'}}) { |
| push @{$self->{'formatting_context'}->[-1]->{'text_context'}}, 'ctx_raw'; |
| $height = _convert($self, {'contents' |
| => $element->{'args'}->[2]->{'contents'}}); |
| my $old_context = pop @{$self->{'formatting_context'}->[-1]->{'text_context'}}; |
| die if ($old_context ne 'ctx_raw'); |
| if ($height !~ /\S/) { |
| $height = undef; |
| } |
| } |
| $result .= "\\includegraphics"; |
| if (defined($width) or defined($height)) { |
| $result .= "["; |
| if (defined($width)) { |
| $result .= "width=$width"; |
| if (defined($height)) { |
| $result .= ","; |
| } |
| } |
| if (defined($height)) { |
| $result .= "height=$height"; |
| } |
| $result .= "]"; |
| } |
| $result .= "{$image_file}"; |
| } |
| return $result; |
| } elsif ($cmdname eq 'email') { |
| if ($element->{'args'}) { |
| my $name; |
| my $converted_name; |
| my $email; |
| my $email_text; |
| if (scalar (@{$element->{'args'}}) == 2 |
| and defined($element->{'args'}->[1]) |
| and $element->{'args'}->[1]->{'contents'} |
| and @{$element->{'args'}->[1]->{'contents'}}) { |
| $name = $element->{'args'}->[1]->{'contents'}; |
| $converted_name = _convert($self, {'contents' => $name}); |
| } |
| if (defined($element->{'args'}->[0]) |
| and $element->{'args'}->[0]->{'contents'} |
| and @{$element->{'args'}->[0]->{'contents'}}) { |
| $email = $element->{'args'}->[0]->{'contents'}; |
| $email_text |
| = $self->_protect_url(Texinfo::Convert::Text::convert_to_text( |
| {'contents' => $email}, |
| {'code' => 1, %{$self->{'convert_text_options'}}})); |
| } |
| if ($name and $email) { |
| $result .= "\\href{mailto:$email_text}{$converted_name}"; |
| } elsif ($email) { |
| $result .= "\\href{mailto:$email_text}{\\nolinkurl{$email_text}}"; |
| } elsif ($name) { |
| $result .= $converted_name; |
| } |
| } |
| return $result; |
| } elsif ($cmdname eq 'uref' or $cmdname eq 'url') { |
| if ($element->{'args'}) { |
| if (scalar(@{$element->{'args'}}) == 3 |
| and defined($element->{'args'}->[2]) |
| and $element->{'args'}->[2]->{'contents'} |
| and @{$element->{'args'}->[2]->{'contents'}}) { |
| unshift @{$self->{'current_contents'}->[-1]}, |
| {'contents' => $element->{'args'}->[2]->{'contents'}}; |
| } elsif ($element->{'args'}->[0] |
| and $element->{'args'}->[0]->{'contents'} |
| and @{$element->{'args'}->[0]->{'contents'}}) { |
| my $url_content = $element->{'args'}->[0]->{'contents'}; |
| my $url_text = $self->_protect_url( |
| Texinfo::Convert::Text::convert_to_text( |
| {'contents' => $url_content}, |
| {'code' => 1, %{$self->{'convert_text_options'}}})); |
| if (scalar(@{$element->{'args'}}) == 2 |
| and defined($element->{'args'}->[1]) |
| and $element->{'args'}->[1]->{'contents'} |
| and @{$element->{'args'}->[1]->{'contents'}}) { |
| my $description = _convert($self, {'contents', |
| $element->{'args'}->[1]->{'contents'}}); |
| my $text = $self->gdt('{text} ({url})', |
| {'text' => $description, 'url' => "\\nolinkurl{$url_text}"}, |
| 'translated_text'); |
| $result .= "\\href{$url_text}{$text}"; |
| return $result; |
| } else { |
| $result .= "\\url{$url_text}"; |
| return $result; |
| } |
| } elsif (scalar(@{$element->{'args'}}) == 2 |
| and defined($element->{'args'}->[1]) |
| and $element->{'args'}->[1]->{'contents'} |
| and @{$element->{'args'}->[1]->{'contents'}}) { |
| unshift @{$self->{'current_contents'}->[-1]}, |
| {'contents' => $element->{'args'}->[1]->{'contents'}}; |
| } |
| } |
| return $result; |
| } elsif ($cmdname eq 'footnote') { |
| _push_new_context($self, 'footnote'); |
| $result .= '\footnote{'; |
| $result .= $self->_convert($element->{'args'}->[0]); |
| $result .= '}'; |
| _pop_context($self); |
| return $result; |
| } elsif ($cmdname eq 'anchor') { |
| my $anchor_label = _tree_anchor_label($element->{'extra'}->{'node_content'}); |
| $result .= "\\label{$anchor_label}%\n"; |
| return $result; |
| } elsif ($ref_commands{$cmdname}) { |
| if (scalar(@{$element->{'args'}})) { |
| my @args; |
| for my $arg (@{$element->{'args'}}) { |
| if (defined $arg->{'contents'} and @{$arg->{'contents'}}) { |
| push @args, $arg->{'contents'}; |
| } else { |
| push @args, undef; |
| } |
| } |
| if ($cmdname eq 'inforef' and scalar(@args) == 3) { |
| $args[3] = $args[2]; |
| $args[2] = undef; |
| } |
| my $book = ''; |
| if (defined($args[4])) { |
| $book = _convert($self, {'contents' => $args[4]}); |
| } |
| |
| my $file_contents; |
| # FIXME not sure if Texinfo TeX uses the external node manual |
| # specified as part of the node name with manual name prependended |
| # in parentheses |
| if (defined($args[3])) { |
| $file_contents = $args[3]; |
| } elsif ($element->{'extra'} |
| and $element->{'extra'}->{'node_argument'} |
| and defined($element->{'extra'}->{'node_argument'}->{'normalized'}) |
| and $element->{'extra'}->{'node_argument'}->{'manual_content'}) { |
| $file_contents = $element->{'extra'}->{'node_argument'}->{'manual_content'}; |
| } |
| my $filename = ''; |
| if ($file_contents) { |
| push @{$self->{'formatting_context'}->[-1]->{'code'}}, 1; |
| $filename = _convert($self, {'contents' => $file_contents}); |
| pop @{$self->{'formatting_context'}->[-1]->{'code'}}; |
| } |
| |
| if ($cmdname ne 'inforef' and $book eq '' and $filename eq '' |
| and $element->{'extra'} |
| and $element->{'extra'}->{'node_argument'} |
| and defined($element->{'extra'}->{'node_argument'}->{'normalized'}) |
| and !$element->{'extra'}->{'node_argument'}->{'manual_content'} |
| and $self->{'labels'} |
| and $self->{'labels'}->{$element->{'extra'}->{'node_argument'}->{'normalized'}}) { |
| # internal reference |
| my $reference |
| = $self->{'labels'}->{$element->{'extra'}->{'node_argument'}->{'normalized'}}; |
| my $reference_node_content = $reference->{'extra'}->{'node_content'}; |
| |
| my $section_command; |
| if ($reference->{'extra'}->{'associated_section'}) { |
| $section_command = $reference->{'extra'}->{'associated_section'}; |
| } elsif ($reference->{'cmdname'} ne 'float') { |
| my $normalized_name |
| = $element->{'extra'}->{'node_argument'}->{'normalized'}; |
| if ($self->{'normalized_nodes_associated_section'} |
| and $self->{'normalized_nodes_associated_section'}->{$normalized_name}) { |
| $section_command |
| = $self->{'normalized_nodes_associated_section'}->{$normalized_name}; |
| } elsif ($reference->{'cmdname'} eq 'node') { |
| # can only happen if there is no sectioning commands at all, |
| # otherwise it would have been associated in |
| # _associate_other_nodes_to_sections. Nothing to do in that case. |
| } else { |
| # an anchor. Find associated section using top level parent @-command. |
| my $current = $reference; |
| while ($current->{'parent'}) { |
| $current = $current->{'parent'}; |
| if ($current->{'cmdname'} |
| and $root_commands{$current->{'cmdname'}}) { |
| if ($current->{'cmdname'} ne 'node') { |
| $section_command = $current; |
| } else { |
| if ($current->{'extra'}->{'associated_section'}) { |
| $section_command = $current->{'extra'}->{'associated_section'}; |
| } elsif (exists($current->{'extra'}->{'normalized'}) |
| and $self->{'normalized_nodes_associated_section'} |
| ->{$current->{'extra'}->{'normalized'}}) { |
| $section_command |
| = $self->{'normalized_nodes_associated_section'} |
| ->{$current->{'extra'}->{'normalized'}}; |
| } |
| } |
| last; |
| } elsif ($current->{'type'} |
| and $current->{'type'} eq 'before_node_section') { |
| # anchor before Top node, can be in copying, titlepage, or directly |
| # in the main document. Could also be before setfilename. |
| last; |
| } |
| } |
| if (defined($section_command)) { |
| # set the association with anchor |
| $self->{'normalized_nodes_associated_section'}->{$normalized_name} |
| = $section_command; |
| } elsif (not defined($current->{'parent'})) { |
| # that means that it is an anchor, but we did not find an root |
| # sectioning command nor 'before_node_section' type, which |
| # should not be possible. |
| print STDERR "BUG/TODO assoc ".$reference->{'cmdname'}.": $normalized_name: ".join("|", sort(keys(%{$reference->{'extra'}})))."\n"; |
| } |
| } |
| } |
| # reference to a float with a label |
| my $float_type; |
| if (exists($reference->{'cmdname'}) |
| and $reference->{'cmdname'} eq 'float') { |
| if ($reference->{'extra'}->{'type'} |
| and $reference->{'extra'}->{'type'}->{'normalized'} ne '') { |
| my $float_type_contents = $reference->{'extra'}->{'type'}->{'content'}; |
| $float_type = _convert($self, {'contents' => $float_type_contents}); |
| } else { |
| $float_type = ''; |
| } |
| } |
| my $text_representation; |
| if ($self->{'formatting_context'}->[-1]->{'in_sectioning_command_heading'}) { |
| # hyperref leads, understandably to some errors in a heading for |
| # the table of content. In that case, setup a text representation. |
| $text_representation = ''; |
| } |
| # TODO: should translate |
| my $reference_result = ''; |
| if ($cmdname eq 'xref') { |
| $reference_result = "See "; |
| } elsif ($cmdname eq 'pxref') { |
| $reference_result = "see "; |
| } elsif ($cmdname eq 'ref') { |
| } |
| $text_representation .= $reference_result |
| if defined($text_representation); |
| my $name; |
| if (defined($args[2])) { |
| $name = $args[2]; |
| } elsif (not defined($float_type)) { |
| if (defined($self->get_conf('xrefautomaticsectiontitle')) |
| and $self->get_conf('xrefautomaticsectiontitle') eq 'on' |
| and $section_command) { |
| $name = $section_command->{'args'}->[0]->{'contents'}; |
| } else { |
| $name = $reference_node_content; |
| } |
| } |
| my $reference_label = _tree_anchor_label($reference_node_content); |
| |
| my $name_text; |
| if (defined($name)) { |
| $name_text = _convert($self, {'contents' => $name}); |
| $text_representation .= $name_text if (defined($text_representation)); |
| } |
| |
| # FIXME translation |
| if (defined($float_type)) { |
| # no page for float reference in Texinfo TeX |
| if (defined($name_text)) { |
| $reference_result .= "\\hyperref[$reference_label]{$name_text}"; |
| } else { |
| if ($float_type ne '') { |
| $reference_result |
| .= "\\hyperref[$reference_label]{$float_type~\\ref*{$reference_label}}"; |
| $text_representation .= $float_type |
| if (defined($text_representation)); |
| } else { |
| $reference_result |
| .= "\\hyperref[$reference_label]{\\ref*{$reference_label}}"; |
| } |
| } |
| } else { |
| # FIXME seems like a , should be added last, but only if not |
| # followed by punctuation which means a painful look ahead |
| # code to do... From the Texinfo manual: |
| # When processing with TeX, a comma is automatically inserted after the page number |
| # for cross-references to within the same manual, unless the closing brace of the argument |
| # is followed by non-whitespace (such as a comma or period). |
| # |
| # If an unwanted comma is added, follow the argument with a command such as @: |
| if ($reference->{'cmdname'} and $reference->{'cmdname'} eq 'node' |
| and $section_command) { |
| if ($section_command->{'structure'}->{'section_level'} > 1) { |
| # TODO command that could be used for translation \sectionname does |
| # not exist in the default case. it is defined in the pagenote package together with |
| # \pagename which is page in the default case, but it is unclear if this |
| # can be used as a basis for translations |
| $reference_result |
| .= "\\hyperref[$reference_label]{Section~\\ref*{$reference_label} [$name_text], page~\\pageref*{$reference_label}}"; |
| } else { |
| # TODO translation |
| $reference_result |
| .= "\\hyperref[$reference_label]{\\chaptername~\\ref*{$reference_label} [$name_text], page~\\pageref*{$reference_label}}"; |
| } |
| } else { |
| # anchor or document without sectioning commands |
| # TODO translation |
| $reference_result |
| .= "\\hyperref[$reference_label]{[$name_text], page~\\pageref*{$reference_label}}"; |
| } |
| } |
| if (not defined($text_representation)) { |
| $result .= $reference_result; |
| } else { |
| $result .= '\texorpdfstring{'.$reference_result.'}{' |
| .$text_representation.'}'; |
| } |
| return $result; |
| } else { |
| # external ref |
| # TODO hyper reference to manual file which seems to be implemented |
| # in recent Texinfo TeX |
| # TODO: should translate |
| if ($cmdname eq 'xref') { |
| $result .= "See "; |
| } elsif ($cmdname eq 'pxref') { |
| $result .= "see "; |
| } elsif ($cmdname eq 'ref') { |
| } |
| my $name; |
| if (defined($args[2])) { |
| $name = $args[2]; |
| } elsif (defined($args[0])) { |
| $name = $args[0]; |
| } |
| my $name_text; |
| if (defined($name)) { |
| $name_text = _convert($self, {'contents' => $name}); |
| } |
| |
| if ($book ne '') { |
| if (defined ($name_text)) { |
| # TODO translation |
| $result .= "Section ``$name_text'' in \\textsl{$book}"; |
| } else { |
| $result .= "\\textsl{$book}"; |
| } |
| } elsif ($filename ne '') { |
| if (defined ($name_text)) { |
| # TODO translation |
| $result .= "Section ``$name_text'' in \\texttt{$filename}"; |
| } else { |
| $result .= "\\texttt{$filename}"; |
| } |
| } elsif ($name_text) { |
| $result .= $name_text; |
| } |
| } |
| return $result; |
| } |
| return $result; |
| } elsif ($explained_commands{$cmdname}) { |
| if ($element->{'args'} |
| and defined($element->{'args'}->[0]) |
| and $element->{'args'}->[0]->{'contents'} |
| and @{$element->{'args'}->[0]->{'contents'}}) { |
| # in abbr spaces never end a sentence. |
| my $argument; |
| if ($cmdname eq 'abbr') { |
| $argument = {'type' => '_dot_not_end_sentence', |
| 'contents' => $element->{'args'}->[0]->{'contents'}}; |
| } else { |
| # TODO in TeX, acronym is in a smaller font (1pt less). |
| $argument = { 'contents' => $element->{'args'}->[0]->{'contents'}}; |
| } |
| if (scalar (@{$element->{'args'}}) == 2 |
| and defined($element->{'args'}->[-1]) |
| and $element->{'args'}->[-1]->{'contents'} |
| and @{$element->{'args'}->[-1]->{'contents'}}) { |
| my $prepended = $self->gdt('{abbr_or_acronym} ({explanation})', |
| {'abbr_or_acronym' => $argument, |
| 'explanation' => $element->{'args'}->[-1]->{'contents'}}); |
| $result .= _convert($self, $prepended); |
| } else { |
| $result .= _convert($self, $argument); |
| } |
| } |
| return $result; |
| } elsif ($Texinfo::Commands::brace_commands{$cmdname} |
| and $Texinfo::Commands::brace_commands{$cmdname} eq 'inline') { |
| my $arg_index = 1; |
| if ($cmdname eq 'inlinefmtifelse' |
| and (!$element->{'extra'}->{'format'} |
| or !$self->{'expanded_formats_hash'}->{$element->{'extra'}->{'format'}})) { |
| $arg_index = 2; |
| } |
| if (scalar(@{$element->{'args'}}) > $arg_index |
| and defined($element->{'args'}->[$arg_index]) |
| and $element->{'args'}->[$arg_index]->{'contents'} |
| and scalar(@{$element->{'args'}->[$arg_index]->{'contents'}})) { |
| if ($cmdname eq 'inlineraw') { |
| push @{$self->{'formatting_context'}->[-1]->{'text_context'}}, 'ctx_raw'; |
| } |
| $result .= _convert($self, {'contents' |
| => $element->{'args'}->[$arg_index]->{'contents'}}); |
| if ($cmdname eq 'inlineraw') { |
| my $old_context = pop @{$self->{'formatting_context'}->[-1]->{'text_context'}}; |
| die if ($old_context ne 'ctx_raw'); |
| } |
| } |
| return $result; |
| } elsif ($math_commands{$cmdname}) { |
| push @{$self->{'formatting_context'}->[-1]->{'text_context'}}, 'ctx_math'; |
| if (not exists($block_commands{$cmdname})) { |
| push @{$self->{'formatting_context'}->[-1]->{'math_style'}}, 'one-line'; |
| if ($cmdname eq 'math') { |
| if ($element->{'args'}) { |
| $result .= '$'; |
| $result .= _convert($self, $element->{'args'}->[0]); |
| $result .= '$'; |
| } |
| } |
| my $old_context = pop @{$self->{'formatting_context'}->[-1]->{'text_context'}}; |
| die if ($old_context ne 'ctx_math'); |
| my $old_math_style = pop @{$self->{'formatting_context'}->[-1]->{'math_style'}}; |
| die if ($old_math_style ne 'one-line'); |
| return $result; |
| } else { |
| if ($cmdname eq 'displaymath') { |
| push @{$self->{'formatting_context'}->[-1]->{'math_style'}}, 'one-line'; |
| # close all preformatted formats |
| $preformatted_to_reopen |
| = [@{$self->{'formatting_context'}->[-1]->{'preformatted_context'}}]; |
| $result .= _close_preformatted_stack($self, $preformatted_to_reopen); |
| $result .= "\\[\n"; |
| } |
| } |
| } elsif ($cmdname eq 'caption' or $cmdname eq 'shortcaption') { |
| if (not defined($element->{'extra'}) |
| or not defined($element->{'extra'}->{'float'})) { |
| return $result; |
| } |
| my $float = $element->{'extra'}->{'float'}; |
| my $shortcaption; |
| if ($cmdname eq 'shortcaption') { |
| if ($float->{'extra'}->{'caption'}) { |
| # nothing to do, will use @shortcaption when converting @caption |
| return $result; |
| } else { |
| # shortcaption used as caption; |
| } |
| } else { |
| if ($float->{'extra'}->{'shortcaption'}) { |
| $shortcaption = $float->{'extra'}->{'shortcaption'}; |
| } |
| } |
| my $caption_text = ''; |
| if ($element->{'args'}->[0]->{'contents'}) { |
| _push_new_context($self, 'latex_caption'); |
| $caption_text = _convert($self, |
| {'contents' => $element->{'args'}->[0]->{'contents'}}); |
| _pop_context($self); |
| } |
| |
| $result .= '\caption'; |
| |
| if (defined($shortcaption) |
| and $shortcaption->{'args'}->[0]->{'contents'}) { |
| _push_new_context($self, 'latex_shortcaption'); |
| my $shortcaption_text = _convert($self, |
| {'contents' => $shortcaption->{'args'}->[0]->{'contents'}}); |
| _pop_context($self); |
| $result .= '['.$shortcaption_text.']'; |
| } |
| $result .= "{$caption_text}\n"; |
| return $result; |
| } elsif ($cmdname eq 'titlefont') { |
| $result .= _title_font($self, $element); |
| return $result; |
| } elsif ($cmdname eq 'U') { |
| my $arg; |
| if ($element->{'args'} |
| and $element->{'args'}->[0] |
| and $element->{'args'}->[0]->{'contents'} |
| and $element->{'args'}->[0]->{'contents'}->[0] |
| and $element->{'args'}->[0]->{'contents'}->[0]->{'text'}) { |
| $arg = $element->{'args'}->[0]->{'contents'}->[0]->{'text'}; |
| } |
| if ($arg) { |
| # Syntactic checks on the value were already done in Parser.pm, |
| # but we have one more thing to test: since this is the one |
| # place where we might output actual UTF-8 binary bytes, we have |
| # to check that it is possible. If not, silently fall back to |
| # plain text, on the theory that the user wants something. |
| # Note that being able to output an unicode point as encoded |
| # character does not mean that LaTeX will be able to process it. |
| my $res; |
| if ($self->{'to_utf8'}) { |
| my $possible_conversion |
| = Texinfo::Convert::Unicode::check_unicode_point_conversion($arg, |
| $self->{'debug'}); |
| if ($possible_conversion) { |
| $res = chr(hex($arg)); # ok to call chr |
| } else { |
| $res = "U+$arg"; |
| } |
| } else { |
| $res = "U+$arg"; # not outputting UTF-8 |
| } |
| $result .= _protect_text($self, $res); |
| } |
| return $result; |
| } elsif ($cmdname eq 'value') { |
| my $expansion = $self->gdt('@{No value for `{value}\'@}', |
| {'value' => $element->{'extra'}->{'flag'}}); |
| $expansion = {'type' => 'paragraph', |
| 'contents' => [$expansion]}; |
| $result .= _convert($self, $expansion); |
| return $result; |
| # block commands |
| } elsif (exists($block_commands{$cmdname})) { |
| if ($LaTeX_environment_commands{$cmdname}) { |
| my $environment_options = _set_environment_options($self, $cmdname, $element); |
| foreach my $environment (@{$LaTeX_environment_commands{$cmdname}}) { |
| $self->{'fixed_width_environments'}->{$environment} = 1 |
| if ($LaTeX_fixed_width_environments{$environment}); |
| $result .= "\\begin{".$environment."}"; |
| if (defined($environment_options) and |
| exists($environment_options->{$environment})) { |
| $result .= '['.$environment_options->{$environment}.']'; |
| } |
| # For @flushright and @flushleft, which don't use 'preformatted' |
| # elements, unlike @display and @format. This comments out the |
| # newline. |
| $result .= '%' if $environment eq 'Texinfopreformatted'; |
| $result .= "\n"; |
| } |
| if ($LaTeX_environment_packages{$cmdname}) { |
| foreach my $package (@{$LaTeX_environment_packages{$cmdname}}) { |
| $self->{'packages'}->{$package} = 1; |
| } |
| } |
| if ($LaTeX_list_environments{$cmdname}) { |
| $self->{'list_environments'}->{$LaTeX_list_environments{$cmdname}} = 1; |
| } |
| } |
| if ($preformatted_commands{$cmdname}) { |
| _open_preformatted_command($self, $cmdname); |
| } elsif ($block_raw_commands{$cmdname}) { |
| push @{$self->{'formatting_context'}->[-1]->{'text_context'}}, 'ctx_raw'; |
| } |
| if ($block_commands{$cmdname} |
| and $block_commands{$cmdname} eq 'item_line') { |
| # may be undef, in particular if the command is not a style command, |
| # for example @email |
| my $description_command_format |
| = _xtable_description_command_format($self, $element); |
| push @{$self->{'formatting_context'}->[-1]->{'table_command_format'}}, |
| $description_command_format; |
| } |
| if ($cmdname eq 'quotation' or $cmdname eq 'smallquotation') { |
| # this is only used to avoid @author converted as |
| # a @titlepage author, for a @quotation in @titlepage @author |
| $self->{'formatting_context'}->[-1]->{'in_quotation'} += 1; |
| if ($element->{'args'} and $element->{'args'}->[0] |
| and $element->{'args'}->[0]->{'contents'} |
| and @{$element->{'args'}->[0]->{'contents'}}) { |
| my $prepended = $self->gdt('@b{{quotation_arg}:} ', |
| {'quotation_arg' => $element->{'args'}->[0]->{'contents'}}); |
| $result .= $self->_convert($prepended); |
| } |
| } elsif ($cmdname eq 'multitable') { |
| # for m{} in tabular header |
| $self->{'packages'}->{'array'} = 1; |
| $result .= '\begin{tabular}{'; |
| my @fractions; |
| if ($element->{'extra'}->{'columnfractions'}) { |
| @fractions |
| = @{$element->{'extra'}->{'columnfractions'}->{'extra'}->{'misc_args'}}; |
| } elsif ($element->{'extra'}->{'prototypes'}) { |
| my @prototypes_length; |
| my $total_length = 0.; |
| foreach my $prototype (@{$element->{'extra'}->{'prototypes'}}) { |
| # not clear what to do here. For now use the text width |
| my $prototype_text |
| = Texinfo::Convert::Text::convert_to_text($prototype, |
| $self->{'convert_text_options'}); |
| my $length = Texinfo::Convert::Unicode::string_width($prototype_text); |
| $total_length += $length; |
| push @prototypes_length, $length; |
| } |
| if ($total_length > 0.) { |
| foreach my $length (@prototypes_length) { |
| push @fractions, $length / $total_length; |
| } |
| } |
| } |
| $result .= join(' ', map {'m{'.$_.'\textwidth}'} @fractions); |
| $result .= "}%\n"; |
| } elsif ($cmdname eq 'float') { |
| if (not $self->{'formatting_context'}->[-1]->{'in_skipped_node_top'}) { |
| my $normalized_float_type = ''; |
| if ($element->{'extra'}->{'type'}) { |
| $normalized_float_type = $element->{'extra'}->{'type'}->{'normalized'}; |
| } |
| if (not exists($self->{'normalized_float_latex'}->{$normalized_float_type})) { |
| cluck("\@float $normalized_float_type: not found\n"); |
| return ''; |
| } |
| my $latex_float_name = $self->{'normalized_float_latex'}->{$normalized_float_type}; |
| _push_new_context($self, 'float'.$latex_float_name); |
| $result .= "\\begin{$latex_float_name}\n"; |
| } |
| } |
| } elsif ($cmdname eq 'node' or $sectioning_heading_commands{$cmdname}) { |
| my $node_element; |
| if ($cmdname eq 'node') { |
| $node_element = $element; |
| } elsif ($cmdname eq 'part' and $element->{'extra'} |
| and $element->{'extra'}->{'part_following_node'}) { |
| $node_element = $element->{'extra'}->{'part_following_node'}; |
| } |
| if ($node_element and $node_element->{'extra'} |
| and $node_element->{'extra'}->{'normalized'} |
| and $node_element->{'extra'}->{'normalized'} eq 'Top') { |
| $self->{'formatting_context'}->[-1]->{'in_skipped_node_top'} = 1; |
| } |
| if ($cmdname eq 'node') { |
| # add the label only if not associated with a section |
| if (not $element->{'extra'}->{'associated_section'}) { |
| my $node_label |
| = _tree_anchor_label($element->{'extra'}->{'node_content'}); |
| $result .= "\\label{$node_label}%\n"; |
| } |
| } else { |
| if ($cmdname eq 'appendix' and not $self->{'appendix_done'}) { |
| $result .= "\\appendix\n"; |
| $self->{'appendix_done'} = 1; |
| } |
| if (not $self->{'formatting_context'}->[-1]->{'in_skipped_node_top'}) { |
| my $heading = ''; |
| if ($element->{'args'}->[0]->{'contents'}) { |
| # It is useful to know that this is a heading formatting as |
| # the formatted heading is in the table of content, and some formatting |
| # may be different for that case, for instance with \texorpdfstring |
| $self->{'formatting_context'}->[-1]->{'in_sectioning_command_heading'} = 1; |
| $heading = $self->_convert({'contents' => $element->{'args'}->[0]->{'contents'}}); |
| $self->{'formatting_context'}->[-1]->{'in_sectioning_command_heading'} = 0; |
| } |
| my $section_cmd = $section_map{$cmdname}; |
| die "BUG: no section_map for $cmdname" |
| if (not defined($section_map{$cmdname})); |
| if ($cmdname ne 'centerchap') { |
| $result .= "\\".$section_cmd."{{$heading}}\n"; |
| } else { |
| $result .= "\\".$section_cmd."{{\\centering $heading}}\n"; |
| } |
| # NOTE we used an extra layer of { } to avoid buggy interactions with |
| # square brackets when the titleps package is being used. |
| $self->{'extra_definitions'}->{'Texinfonopagebreakheading'} = 1 |
| if $section_cmd =~ /^Texinfonopagebreakheading\{/; |
| } |
| # we add a label even if in_skipped_node_top (should only |
| # be for the Top node, as another node ends in_skipped_node_top). |
| if ($element->{'extra'}->{'associated_node'}) { |
| my $associated_node = $element->{'extra'}->{'associated_node'}; |
| my $node_label |
| = _tree_anchor_label($associated_node->{'extra'}->{'node_content'}); |
| $result .= "\\label{$node_label}%\n"; |
| } |
| } |
| } elsif (($cmdname eq 'item' or $cmdname eq 'itemx') |
| and $element->{'args'} and $element->{'args'}->[0] |
| and $element->{'args'}->[0]->{'type'} |
| and $element->{'args'}->[0]->{'type'} eq 'line_arg') { |
| # item in @*table |
| my $last_item = 0; |
| if ($element->{'args'}->[0]->{'contents'}) { |
| my $code_style = 0; |
| my $table_command = $element->{'parent'}->{'parent'}->{'parent'}; |
| if ($table_command->{'extra'} |
| and $table_command->{'extra'}->{'command_as_argument'}) { |
| my $command_as_argument |
| = $table_command->{'extra'}->{'command_as_argument'}->{'cmdname'}; |
| if ($brace_code_commands{$command_as_argument}) { |
| $code_style = 1; |
| } |
| } |
| if ($code_style) { |
| push @{$self->{'formatting_context'}->[-1]->{'code'}}, 1; |
| } |
| my $converted_arg = _convert($self, $element->{'args'}->[0]); |
| if ($code_style) { |
| pop @{$self->{'formatting_context'}->[-1]->{'code'}}; |
| } |
| $self->{'formatting_context'}->[-1]->{'nr_table_items_context'}->[-1] -= 1; |
| my $description_format_command |
| = $self->{'formatting_context'}->[-1]->{'table_command_format'}->[-1]; |
| if (defined($description_format_command)) { |
| $converted_arg = "${description_format_command}\{${converted_arg}\}"; |
| } |
| $result .= $converted_arg; |
| if ($self->{'formatting_context'}->[-1]->{'nr_table_items_context'}->[-1] > 0) { |
| $result .= '\\\\'."\n"; |
| } else { |
| $last_item = 1; |
| } |
| } |
| my $index_entry = _index_entry($self, $element); |
| if ($index_entry ne '' and $last_item) { |
| $result .= "\n"; |
| } |
| $result .= $index_entry; |
| } elsif ($cmdname eq 'item' and $element->{'parent'}->{'cmdname'} |
| and $block_commands{$element->{'parent'}->{'cmdname'}} |
| and $block_commands{$element->{'parent'}->{'cmdname'}} eq 'item_container') { |
| # item in @enumerate and @itemize |
| $result .= '\item '; |
| } elsif ($cmdname eq 'headitem' or $cmdname eq 'item' |
| or $cmdname eq 'tab') { |
| # nothing to do here. The condition ensures that the commands are not |
| # considered as unknown commands in the else below. |
| } elsif ($cmdname eq 'center') { |
| if ($element->{'args'}->[0]->{'contents'}) { |
| $result .= "\\begin{center}\n"; |
| $result .= $self->_convert ( |
| {'contents' => $element->{'args'}->[0]->{'contents'}}); |
| $result .= "\n\\end{center}\n"; |
| } |
| return $result; |
| } elsif ($cmdname eq 'exdent') { |
| if ($element->{'args'}->[0]->{'contents'}) { |
| # FIXME \leavevmode{} is added to avoid |
| # ! LaTeX Error: There's no line here to end. |
| # but it is not clearly correct |
| $result .= "\\leavevmode{}\\\\\n"; |
| $result .= "\\hbox{\\kern -\\leftmargin}%\n"; |
| $result .= $self->_convert( |
| {'contents' => $element->{'args'}->[0]->{'contents'}})."\n"; |
| $result .= "\\\\\n"; |
| } |
| return $result; |
| } elsif ($cmdname eq 'verbatiminclude') { |
| my $expansion = Texinfo::Convert::Utils::expand_verbatiminclude($self, |
| $self, $element); |
| unshift @{$self->{'current_contents'}->[-1]}, $expansion |
| if ($expansion); |
| return $result; |
| } elsif ($cmdname eq 'insertcopying') { |
| if ($self->{'global_commands'} |
| and $self->{'global_commands'}->{'copying'}) { |
| unshift @{$self->{'current_contents'}->[-1]}, |
| {'contents' => $self->{'global_commands'}->{'copying'}->{'contents'}}; |
| } |
| return $result; |
| } elsif ($cmdname eq 'printindex') { |
| my $index_name; |
| if ($element->{'extra'} and $element->{'extra'}->{'misc_args'} |
| and defined($element->{'extra'}->{'misc_args'}->[0])) { |
| $index_name = $element->{'extra'}->{'misc_args'}->[0]; |
| if (exists($self->{'index_entries'}) |
| and exists($self->{'index_entries'}->{$index_name})) { |
| $result .= "\\printindex[$index_name]\n"; |
| } |
| } |
| return $result; |
| } elsif ($cmdname eq 'listoffloats') { |
| if ($element->{'extra'} and $element->{'extra'}->{'type'} |
| and defined($element->{'extra'}->{'type'}->{'normalized'}) |
| and $self->{'floats'} |
| and $self->{'floats'}->{$element->{'extra'}->{'type'}->{'normalized'}} |
| and @{$self->{'floats'}->{$element->{'extra'}->{'type'}->{'normalized'}}}) { |
| my $normalized_float_type = $element->{'extra'}->{'type'}->{'normalized'}; |
| if (not exists($self->{'normalized_float_latex'}->{$normalized_float_type})) { |
| cluck("\@listoffloats $normalized_float_type: not found\n"); |
| return $result; |
| } |
| my $latex_float_name = $self->{'normalized_float_latex'}->{$normalized_float_type}; |
| # a listoffigures in @example leads to an error in the |
| # lof file. So stop and restart preformatted environments |
| $preformatted_to_reopen |
| = [@{$self->{'formatting_context'}->[-1]->{'preformatted_context'}}]; |
| $result .= _close_preformatted_stack($self, $preformatted_to_reopen); |
| if (exists($LaTeX_floats{$latex_float_name})) { |
| $result .= $LaTeX_floats{$latex_float_name}."\n"; |
| } else { |
| $result .= "\\listof{$latex_float_name}{}\n"; |
| } |
| $result .= _open_preformatted_stack($self, $preformatted_to_reopen); |
| } |
| return $result; |
| } elsif ($cmdname eq 'page') { |
| $result .= _finish_front_cover_page($self); |
| # the phantom is added such that successive new pages create blank pages |
| $result .= "\\newpage{}%\n\\phantom{blabla}%\n"; |
| return $result; |
| } elsif ($cmdname eq 'indent') { |
| # TODO it seems that \indent only works with \setlength{\parindent}{0pt} |
| # which makes it quite different from Texinfo @indent |
| #$result .= "\\indent{}"; |
| } elsif ($cmdname eq 'noindent') { |
| # spaces after noindent are in ignorable_space_types and are therefore |
| # munged which is ok as otherwise it could add a leading space |
| $result .= "\\noindent{}"; |
| return $result; |
| } elsif ($cmdname eq 'sp') { |
| my $sp_nr = 1; |
| if ($element->{'extra'}->{'misc_args'}->[0]) { |
| # this useless copy avoids perl changing the type to integer! |
| $sp_nr = $element->{'extra'}->{'misc_args'}->[0]; |
| } |
| # FIXME \vskip is a TeX primitive, so the syntax seems to be |
| # different from LaTeX, and some people warn against using |
| # TeX primitives. However there is no obvious corresponding |
| # command in LaTeX, except for adding enough \\. |
| $result .= "\\vskip $sp_nr\\baselineskip %\n"; |
| return $result; |
| } elsif ($cmdname eq 'need') { |
| $self->{'packages'}->{'needspace'} = 1; |
| if ($element->{'extra'}->{'misc_args'}->[0]) { |
| my $need_value = 0.001 * $element->{'extra'}->{'misc_args'}->[0]; |
| $result .= "\\needspace{${need_value}pt}%\n"; |
| } |
| return $result; |
| } elsif (defined($LaTeX_in_heading_commands_formatting{$cmdname})) { |
| $result .= $LaTeX_in_heading_commands_formatting{$cmdname}; |
| return $result; |
| } elsif ($cmdname eq 'title') { |
| my $title_text = _title_font($self, $element); |
| # FIXME In Texinfo TeX the interline space seems more even |
| $result .= "{\\raggedright $title_text}\n"; |
| # same formatting for the rule as in Texinfo TeX |
| $result .= "\\vskip 4pt \\hrule height 4pt width \\hsize \\vskip 4pt\n"; |
| # TODO warn if not in titlepage? Or even not in |
| # $self->{'titlepage_formatting'}->{'in_front_cover'} |
| $self->{'titlepage_formatting'}->{'title'} = 1 |
| if ($self->{'titlepage_formatting'}); |
| } elsif ($cmdname eq 'subtitle') { |
| if ($element->{'args'}->[0]->{'contents'}) { |
| my $subtitle_text = _convert($self, |
| {'contents' => $element->{'args'}->[0]->{'contents'}}); |
| # too much vertical spacing with flushright environment |
| #$result .= "\\begin{flushright}\n"; |
| #$result .= $subtitle_text."\n"; |
| #$result .= "\\end{flushright}\n"; |
| $result .= "\\rightline{$subtitle_text}\n"; |
| } |
| } elsif ($cmdname eq 'author') { |
| if (not $self->{'formatting_context'}->[-1]->{'in_quotation'}) { |
| if ($element->{'args'}->[0]->{'contents'}) { |
| my $author_name = _convert($self, |
| {'contents' => $element->{'args'}->[0]->{'contents'}}); |
| if ($self->{'titlepage_formatting'} |
| and $self->{'titlepage_formatting'}->{'in_front_cover'}) { |
| if (not $self->{'titlepage_formatting'}->{'author'}) { |
| # first author, add space before |
| $self->{'titlepage_formatting'}->{'author'} = 1; |
| $result .= "\\vskip 0pt plus 1filll\n"; |
| } |
| # use \leftline as in Texinfo TeX |
| # FIXME In Texinfo TeX the interline space between @author lines |
| # seems better |
| $result .= "\\leftline{\\Large \\bfseries $author_name}%\n"; |
| } else { |
| # author in regular text. Should not happen |
| $result .= "{\\bfseries $author_name}%\n"; |
| } |
| } |
| return $result; |
| } |
| } elsif ($cmdname eq 'vskip') { |
| if ($element->{'extra'}->{'misc_args'}->[0]) { |
| # no need for space in front and end of line they are in the |
| # argument |
| $result .= "\\vskip$element->{'extra'}->{'misc_args'}->[0]"; |
| } |
| return $result; |
| } elsif ($cmdname eq 'contents') { |
| if (defined($self->get_conf('CONTENTS_OUTPUT_LOCATION')) |
| and $self->get_conf('CONTENTS_OUTPUT_LOCATION') eq 'inline' |
| and $self->{'structuring'} |
| and $self->{'structuring'}->{'sectioning_root'} |
| and not $self->{'formatting_context'}->[-1]->{'in_skipped_node_top'}) { |
| $result .= "\\tableofcontents\\newpage\n"; |
| } |
| return $result; |
| } elsif ($cmdname eq 'shortcontents' or $cmdname eq 'summarycontents') { |
| if ($self->{'structuring'} |
| and $self->{'structuring'}->{'sectioning_root'}) { |
| # TODO see notes at the beginning |
| $result .= ''; |
| } |
| return $result; |
| } elsif ($heading_spec_commands{$cmdname}) { |
| if ($element->{'args'} and $element->{'args'}->[0] |
| and $element->{'args'}->[0]->{'contents'}) { |
| my $custom_headings_specification |
| = Texinfo::Common::split_custom_heading_command_contents( |
| $element->{'args'}->[0]->{'contents'}); |
| $result .= _set_custom_headings($self, $cmdname, |
| $custom_headings_specification); |
| } |
| return $result; |
| # @-commands that have an information for the formatting |
| } elsif ($informative_commands{$cmdname}) { |
| |
| Texinfo::Common::set_informative_command_value($self, $element); |
| |
| if ($cmdname eq 'documentlanguage') { |
| my $language = $self->get_conf('documentlanguage'); |
| $language =~ s/_/-/; |
| $result .= "\\selectlanguage{$language}%\n"; |
| $self->{'packages'}->{'babel'} = 1; |
| } elsif ($cmdname eq 'pagesizes') { |
| my $pagesize_spec = _convert($self, $element->{'args'}->[0]); |
| my @pagesize_args = split(/\s*,\s*/, $pagesize_spec); |
| my @geometry; |
| my $height = shift @pagesize_args; |
| if (defined($height) and $height ne '') { |
| push @geometry, "textheight=$height"; |
| } |
| my $width = shift @pagesize_args; |
| if (defined($width) and $width ne '') { |
| push @geometry, "textwidth=$width"; |
| } |
| if (scalar(@geometry)) { |
| $result .= "\\newgeometry{".join(',', @geometry)."}\n"; |
| $self->{'packages'}->{'geometry'} = 1; |
| } |
| } elsif ($cmdname eq 'paragraphindent' |
| and $element->{'extra'}->{'misc_args'}->[0]) { |
| my $indentation_spec = $element->{'extra'}->{'misc_args'}->[0]; |
| if ($indentation_spec eq 'asis') { |
| # not implemented here, same as in TeX. |
| return $result; |
| } else { |
| my $indentation_spec_arg = $indentation_spec.'em'; |
| if ($indentation_spec eq '0' or $indentation_spec eq 'none') { |
| $indentation_spec_arg = '0pt'; |
| } |
| $result .= "\\setlength{\\parindent}{$indentation_spec_arg}\n"; |
| } |
| } elsif ($cmdname eq 'firstparagraphindent' |
| and $element->{'extra'}->{'misc_args'}->[0]) { |
| my $indentation_spec = $element->{'extra'}->{'misc_args'}->[0]; |
| $result .= "\\makeatletter\n"; |
| if ($indentation_spec eq 'insert') { |
| # From LaTeX indentfirst package: "LaTeX uses the switch |
| # \if@afterindent to decide whether to indent after a section |
| # heading. We just need to make sure that this is always true." |
| $result .= "\\let\\\@afterindentfalse\\\@afterindenttrue\n"; |
| $result .= "\\\@afterindenttrue\n"; |
| } elsif ($indentation_spec eq 'none') { |
| # restore original definition |
| $result .= '\\def\\@afterindentfalse{' |
| . "\\let\\if\@afterindent\\iffalse}\n"; |
| } |
| $result .= "\\makeatother\n"; |
| } elsif ($cmdname eq 'frenchspacing' |
| and $element->{'extra'}->{'misc_args'}->[0]) { |
| my $frenchspacing_spec = $element->{'extra'}->{'misc_args'}->[0]; |
| if ($frenchspacing_spec eq 'on') { |
| $result .= "\\frenchspacing\n"; |
| } elsif ($frenchspacing_spec eq 'off') { |
| $result .= "\\nonfrenchspacing\n"; |
| } |
| } elsif ($cmdname eq 'setchapternewpage' |
| and $element->{'extra'}->{'misc_args'}->[0]) { |
| my $setchapternewpage_spec = $element->{'extra'}->{'misc_args'}->[0]; |
| $result .= _set_chapter_new_page($self, $setchapternewpage_spec); |
| } elsif ($cmdname eq 'headings' |
| and $element->{'extra'}->{'misc_args'}->[0]) { |
| my $headings_spec = $element->{'extra'}->{'misc_args'}->[0]; |
| $result .= _set_headings($self, $headings_spec); |
| } elsif ($cmdname eq 'fonttextsize' |
| and $element->{'extra'} |
| and $element->{'extra'}->{'misc_args'} |
| and $element->{'extra'}->{'misc_args'}->[0]) { |
| my $fontsize = $element->{'extra'}->{'misc_args'}->[0]; |
| # default dimension for changefontsize is pt |
| $result .= "\\changefontsize{$fontsize}\n"; |
| $self->{'packages'}->{'fontsize'} = 1; |
| } elsif ($paper_geometry_commands{$cmdname}) { |
| $result .= "\\geometry{$paper_geometry_commands{$cmdname}}%\n"; |
| $self->{'packages'}->{'geometry'} = 1; |
| } elsif ($cmdname eq 'microtype' |
| and $element->{'extra'}->{'misc_args'}->[0]) { |
| my $microtype_spec = $element->{'extra'}->{'misc_args'}->[0]; |
| if ($microtype_spec eq 'on') { |
| $result .= "\\microtypesetup{activate=true}%\n"; |
| } elsif ($microtype_spec eq 'off') { |
| $result .= "\\microtypesetup{activate=false}%\n"; |
| } |
| $self->{'packages'}->{'microtype'} = 1; |
| } |
| return $result; |
| } else { |
| $unknown_command = 1; |
| } |
| if ($unknown_command |
| and !($element->{'extra'} |
| and ($element->{'extra'}->{'index_entry'})) |
| # commands like def*x are not processed above, since only the def_line |
| # associated is processed. If they have no name and no category they |
| # are not considered as index entries either so they have a specific |
| # condition |
| and !($def_commands{$cmdname} |
| and $cmdname =~ /x$/)) { |
| # this is output for errormsg |
| warn "Unhandled $cmdname\n"; |
| #$result .= "!!!!!!!!! Unhandled $cmdname !!!!!!!!!\n"; |
| } |
| } |
| |
| # open 'type' constructs. |
| if ($element->{'type'}) { |
| if ($element->{'type'} eq 'index_entry_command') { |
| $result .= _index_entry($self, $element); |
| } |
| if ($element->{'type'} eq 'def_line') { |
| if ($element->{'extra'} and $element->{'extra'}->{'def_parsed_hash'} |
| and %{$element->{'extra'}->{'def_parsed_hash'}}) { |
| my $arguments |
| = Texinfo::Convert::Utils::definition_arguments_content($element); |
| my $command; |
| if ($Texinfo::Common::def_aliases{$element->{'extra'}->{'def_command'}}) { |
| $command |
| = $Texinfo::Common::def_aliases{$element->{'extra'}->{'def_command'}}; |
| } else { |
| $command = $element->{'extra'}->{'def_command'}; |
| } |
| |
| my $deftypefnnewline = ($self->get_conf('deftypefnnewline') eq 'on' |
| and ($command eq 'deftypefn' or $command eq 'deftypeop')); |
| |
| my $name; |
| if ($element->{'extra'}->{'def_parsed_hash'}->{'name'}) { |
| $name = $element->{'extra'}->{'def_parsed_hash'}->{'name'}; |
| } else { |
| $name = ''; |
| } |
| my $def_space = ' '; |
| if ($element->{'extra'}->{'omit_def_name_space'}) { |
| $def_space = ''; |
| } |
| |
| my $converted_category; |
| my $category |
| = Texinfo::Convert::Utils::definition_category_tree($self, $element);; |
| if (defined($category)) { |
| # category is converted in normal text context |
| my $converted = _convert($self, $category); |
| $converted_category = "[$converted]"; |
| } |
| |
| $self->{'packages'}->{'tabularx'} = 1; |
| my $def_line_result = ''; |
| # First column (X) is as wide as possible, second column (r) is for |
| # category. @{} removes space at left side of table. |
| # Without \noindent, a def* after a section beginning is indented |
| $def_line_result .= "\\noindent\\begin{tabularx}{\\linewidth}{\@{}Xr}\n"; |
| |
| # This stops the definition line overlapping the category in |
| # case it is hard to break the first line. |
| $def_line_result .= "\\rightskip=5em plus 1 fill "; |
| |
| # In case definition "line" doesn't fit on one line. |
| $def_line_result .= "\\hangindent=2em "; |
| |
| # turn off hyphenation |
| $def_line_result .= "\\hyphenpenalty=10000\n"; |
| |
| $def_line_result .= '\texttt{'; |
| |
| # no end of line in tabularx |
| push @{$self->{'formatting_context'}->[-1]->{'no_eol'}}, 1; |
| # the def* line except for the category is converted in code context |
| push @{$self->{'formatting_context'}->[-1]->{'code'}}, 1; |
| |
| if ($element->{'extra'}->{'def_parsed_hash'}->{'type'}) { |
| $def_line_result .= _convert($self, |
| $element->{'extra'}->{'def_parsed_hash'}->{'type'}); |
| if ($deftypefnnewline) { |
| if (defined($converted_category)) { |
| $def_line_result .= "}& $converted_category\\\\\n\\texttt{" |
| } else { |
| $def_line_result .= "}\\\\\n\\texttt{"; |
| } |
| } else { |
| $def_line_result .= ' '; |
| } |
| } |
| $def_line_result .= _convert($self, $name) if $name; |
| # will contain the command names that have been made known to |
| # embrac, like texttt and need to have the symbol undefined |
| # such that they can be redefined later |
| my $known_embrac_commands; |
| if ($arguments) { |
| $def_line_result .= $def_space; |
| if ($Texinfo::Common::def_no_var_arg_commands{$command}) { |
| $def_line_result .= _convert($self, {'contents' => $arguments}); |
| } else { |
| $self->{'packages'}->{'embrac'} = 1; |
| # we want slanted roman and not slanted typewriter, including |
| # ligatures, as if @r{@slanted{...}} had been used, so output |
| # \textnormal and push 0 on 'code' context. |
| $def_line_result .= '\EmbracOn{}\textnormal{\textsl{'; |
| push @{$self->{'formatting_context'}->[-1]->{'code'}}, 0; |
| push @{$self->{'formatting_context'}->[-1]->{'embrac'}}, |
| {'status' => 1, 'made_known' => {}}; |
| |
| $def_line_result .= _convert($self, {'contents' => $arguments}); |
| |
| # \EmbracOff{} is probably not really needed here as \EmbracOn{} |
| # should be local to the texttt |
| $def_line_result .= '}}\EmbracOff{}'; # \textnormal \textsl |
| pop @{$self->{'formatting_context'}->[-1]->{'code'}}; |
| my $closed_embrac |
| = pop @{$self->{'formatting_context'}->[-1]->{'embrac'}}; |
| if (scalar(keys(%{$closed_embrac->{'made_known'}}))) { |
| $known_embrac_commands |
| = [sort(keys(%{$closed_embrac->{'made_known'}}))] |
| } |
| } |
| } |
| |
| pop @{$self->{'formatting_context'}->[-1]->{'code'}}; |
| $def_line_result .= '}'; # \texttt |
| pop @{$self->{'formatting_context'}->[-1]->{'no_eol'}}; |
| |
| $def_line_result .= "& $converted_category\n" |
| if (defined($converted_category) and not $deftypefnnewline); |
| |
| $def_line_result .= "\\end{tabularx}\n"; |
| # Add commands associated to embrac, prepended to be before tabularx. |
| # If done in tabularx there are redefinition errors, cells are |
| # probably expanded more than once. |
| # |
| # also postpend undefine symbols associated with commands that have |
| # been made known to embrac, such that they can be redefined later |
| # |
| # TODO currently setting EmbracMakeKnown twice leads to an error. |
| # this is triggered by the tests layout formatting_latex test. |
| # So do not use it for now. |
| if (0 and defined($known_embrac_commands)) { |
| $def_line_result .= "\\ExplSyntaxOn%\n"; |
| foreach my $defined_style_embrac (@{$known_embrac_commands}) { |
| # before the tabularx |
| $def_line_result = '\EmbracMakeKnown{'.$defined_style_embrac.'}' |
| ."%\n" .$def_line_result; |
| $def_line_result .= '\cs_undefine:N{\embrac_'.$defined_style_embrac.':nn}'. |
| '\cs_undefine:N{\embrac_orig_'.$defined_style_embrac.':n}'. |
| '\cs_undefine:N{\__embrac_'.$defined_style_embrac.':n}% |
| '; |
| } |
| $def_line_result .= "\\ExplSyntaxOff%\n"; |
| } |
| $result .= "\n".$def_line_result; |
| } |
| $result .= "\n"; |
| $result .= _index_entry($self, $element); |
| } elsif ($element->{'type'} eq 'def_item') { |
| $result .= "\\begin{quote}\n"; |
| # Remove vertical space and start paragaph, avoiding adding |
| # more vertical space. |
| $result .= "\\unskip{\\parskip=0pt\\noindent}%\n"; |
| } elsif ($element->{'type'} eq 'table_term') { |
| $result .= '\item[{\parbox[b]{\linewidth}{%'."\n"; |
| # count @item/@itemx to add //\n to each except for the last |
| my $nr_item = 0; |
| foreach my $content (@{$element->{'contents'}}) { |
| if ($content->{'cmdname'} and |
| ($content->{'cmdname'} eq 'item' |
| or $content->{'cmdname'} eq 'itemx')) { |
| $nr_item++; |
| } |
| } |
| push @{$self->{'formatting_context'}->[-1]->{'nr_table_items_context'}}, |
| $nr_item; |
| } elsif ($element->{'type'} eq 'inter_item') { |
| # the whole @item/@itemx formatting is put in a parbox, in which |
| # there should not be paragraphs, so we remove empty lines from |
| # inter_item. We format directly here while ignoring the empty lines |
| # for performance reasons, and not below like all the contents, to |
| # avoid needing to check if in table items using a context information, |
| # we know that only comments and index entries or a lone preformatted |
| # should be in inter_item. |
| if ($element->{'contents'}) { |
| my $contents; |
| # if in an preformatted context, ie in @example, the inter_item |
| # content is within a preformatted. In that case we use content |
| # from within the preformatted. We do not do anything that is done |
| # in _open_preformatted/_close_preformatted as the only things |
| # that should be in inter_item, besides empty lines we want to |
| # remove, are comments and index entries, which formatting should |
| # not be affected. |
| if ($element->{'contents'}->[0]->{'type'} |
| and $element->{'contents'}->[0]->{'type'} eq 'preformatted') { |
| $contents = $element->{'contents'}->[0]->{'contents'} |
| if $element->{'contents'}->[0]->{'contents'}; |
| } else { |
| $contents = $element->{'contents'}; |
| } |
| foreach my $content (@$contents) { |
| $result .= _convert($self, $content) |
| unless ($content->{'type'} and $content->{'type'} eq 'empty_line'); |
| } |
| } |
| return $result; |
| } elsif ($element->{'type'} eq 'preformatted') { |
| $result .= _open_preformatted($self, $element); |
| } elsif ($element->{'type'} eq '_dot_not_end_sentence') { |
| $self->{'formatting_context'}->[-1]->{'dot_not_end_sentence'} += 1; |
| } elsif ($element->{'type'} eq 'bracketed') { |
| $result .= _protect_text($self, '{'); |
| } |
| } |
| |
| # The processing of contents is done here. |
| if ($element->{'contents'}) { |
| my @contents = @{$element->{'contents'}}; |
| push @{$self->{'current_contents'}}, \@contents; |
| while (@contents) { |
| my $content = shift @contents; |
| my $text = _convert($self, $content); |
| $result .= $text; |
| if ($self->{'debug'} and $self->{'debug'} > 2) { |
| my @str_contents = (); |
| foreach my $item_content (@contents) { |
| push @str_contents, Texinfo::Common::debug_print_element_short($item_content); |
| } |
| print STDERR "C ".Texinfo::Common::debug_print_element_short($element).": ".join("|", @str_contents)."\n"; |
| } |
| } |
| pop @{$self->{'current_contents'}}; |
| } |
| |
| # now closing. First, close types. |
| if ($type) { |
| if ($type eq '_dot_not_end_sentence') { |
| $self->{'formatting_context'}->[-1]->{'dot_not_end_sentence'} -= 1; |
| } elsif ($type eq 'def_item') { |
| $result .= "\\end{quote}\n"; |
| } elsif ($type eq 'table_term') { |
| $result .= '}}]'."\n"; |
| pop @{$self->{'formatting_context'}->[-1]->{'nr_table_items_context'}}; |
| } elsif ($type eq 'bracketed') { |
| $result .= _protect_text($self, '}'); |
| } elsif ($type eq 'preformatted') { |
| $result .= _close_preformatted($self, $element); |
| } elsif ($type eq 'before_item') { |
| # LaTeX environments do not accept text before the first item, add an item |
| if ($result =~ /\S/) { |
| # FIXME if there is only an index element it is content and |
| # triggers an empty \item. It is mitigated by |
| # move_index_entries_after_items for enumerate and itemize, but not |
| # for @*table. For @*table there is relate_index_entries_to_table_entries |
| # but it has no obvious use here |
| if ($block_commands{$element->{'parent'}->{'cmdname'}} |
| and $block_commands{$element->{'parent'}->{'cmdname'}} eq 'item_line') { |
| # it is important to have an empty optional argument otherwise |
| # a quoted command will output the quotes, even with a detection |
| # of empty argument (tested with diverse possibilities) |
| $result = '\item[] '.$result; |
| } else { |
| $result = '\item '.$result; |
| } |
| } |
| } elsif ($type eq 'row') { |
| chomp($result); |
| # can happen with diverse added @-command, in particular index commands |
| if ($result =~ /%$/) { |
| $result .= "\n"; |
| } |
| $result .= '\\\\'."\n"; |
| } elsif ($type eq $latex_document_type) { |
| # type marking the beginning of content |
| $result .= _begin_document($self); |
| } |
| } |
| |
| # close commands |
| if ($cmdname) { |
| if ($block_commands{$cmdname} and $block_commands{$cmdname} eq 'item_line') { |
| pop @{$self->{'formatting_context'}->[-1]->{'table_command_format'}}; |
| } |
| if ($LaTeX_environment_commands{$cmdname}) { |
| foreach my $environment (reverse @{$LaTeX_environment_commands{$cmdname}}) { |
| $result .= "\\end{".$environment."}\n"; |
| } |
| } |
| if ($preformatted_commands{$cmdname}) { |
| _close_preformatted_command($self, $cmdname); |
| } |
| if ($cmdname eq 'float') { |
| # do that at the end of the float to be sure that it is after |
| # the caption |
| if ($element->{'extra'} and $element->{'extra'}->{'node_content'}) { |
| my $float_label |
| = _tree_anchor_label($element->{'extra'}->{'node_content'}); |
| $result .= "\\label{$float_label}%\n"; |
| } |
| if (not $self->{'formatting_context'}->[-1]->{'in_skipped_node_top'}) { |
| my $normalized_float_type = ''; |
| if ($element->{'extra'}->{'type'}) { |
| $normalized_float_type = $element->{'extra'}->{'type'}->{'normalized'}; |
| } |
| # this should never happen as we returned at the command |
| # open. If this happens it means that the tree has been modified... |
| if (not exists($self->{'normalized_float_latex'}->{$normalized_float_type})) { |
| confess("\@float $normalized_float_type: not found\n"); |
| } |
| my $latex_float_name = $self->{'normalized_float_latex'}->{$normalized_float_type}; |
| $result .= "\\end{$latex_float_name}\n"; |
| _pop_context($self); |
| } |
| } elsif ($cmdname eq 'quotation' |
| or $cmdname eq 'smallquotation') { |
| if ($element->{'extra'} and $element->{'extra'}->{'authors'}) { |
| # NOTE when @quotation is in a preformatted environment (@example...), |
| # we are not in a preformatted type here, such that the conversion |
| # does not take into account the preformatted environment. Probably best. |
| foreach my $author (@{$element->{'extra'}->{'authors'}}) { |
| if ($author->{'args'}->[0]->{'contents'}) { |
| $result .= _convert($self, |
| $self->gdt('@center --- @emph{{author}}', |
| {'author' => $author->{'args'}->[0]->{'contents'}})); |
| } |
| } |
| } |
| $self->{'formatting_context'}->[-1]->{'in_quotation'} -= 1; |
| } elsif ($cmdname eq 'multitable') { |
| $result .= '\end{tabular}%'."\n"; |
| } |
| |
| # close the contexts and register the cells |
| if ($block_raw_commands{$cmdname}) { |
| my $old_context = pop @{$self->{'formatting_context'}->[-1]->{'text_context'}}; |
| die if ($old_context ne 'ctx_raw'); |
| } elsif ($block_math_commands{$cmdname}) { |
| my $old_context = pop @{$self->{'formatting_context'}->[-1]->{'text_context'}}; |
| die if ($old_context ne 'ctx_math'); |
| if ($cmdname eq 'displaymath') { |
| $result .= "\\]\n"; |
| # reopen all preformatted commands |
| $result .= _open_preformatted_stack($self, $preformatted_to_reopen); |
| } |
| my $old_math_style = pop @{$self->{'formatting_context'}->[-1]->{'math_style'}}; |
| die if ($old_math_style ne 'one-line'); |
| } elsif ($element->{'parent'}->{'type'} |
| and $element->{'parent'}->{'type'} eq 'row') { |
| my $cell_nr = $element->{'extra'}->{'cell_number'}; |
| my $multitable = $element->{'parent'}->{'parent'}->{'parent'}; |
| my $max_columns = $multitable->{'extra'}->{'max_columns'}; |
| my $add_eol = 0; |
| $add_eol = 1 if (chomp($result)); |
| if ($cell_nr < $max_columns) { |
| $result .= '&'; |
| } |
| $result .= "\n" if ($add_eol); |
| } |
| } |
| |
| return $result; |
| } |
| |
| 1; |
