# $Id: __init__.py 5333 2007-07-10 17:31:28Z grubert $

# Author: Engelbert Gruber <grubert@users.sourceforge.net>

# Copyright: This module has been placed in the public domain.

"""

LaTeX2e document tree Writer.

"""

__docformat__ = 'reStructuredText'

# code contributions from several people included, thanks to all.

# some named: David Abrahams, Julien Letessier, Lele Gaifax, and others.

#

# convention deactivate code by two # e.g. ##.

import sys

import time

import re

import string

from types import ListType

from docutils import frontend, nodes, languages, writers, utils

from docutils.writers.newlatex2e import unicode_map

from docutils.transforms.references import DanglingReferencesVisitor

class Writer(writers.Writer):

    supported = ('latex','latex2e')

    """Formats this writer supports."""

    settings_spec = (

        'LaTeX-Specific Options',

        'The LaTeX "--output-encoding" default is "latin-1:strict".',

        (('Specify documentclass.  Default is "article".',

          ['--documentclass'],

          {'default': 'article', }),

         ('Specify document options.  Multiple options can be given, '

          'separated by commas.  Default is "10pt,a4paper".',

          ['--documentoptions'],

          {'default': '10pt,a4paper', }),

         ('Use LaTeX footnotes. LaTeX supports only numbered footnotes (does it?). '

          'Default: no, uses figures.',

          ['--use-latex-footnotes'],

          {'default': 0, 'action': 'store_true',

           'validator': frontend.validate_boolean}),

         ('Format for footnote references: one of "superscript" or '

          '"brackets".  Default is "superscript".',

          ['--footnote-references'],

          {'choices': ['superscript', 'brackets'], 'default': 'superscript',

           'metavar': '<format>',

           'overrides': 'trim_footnote_reference_space'}),

         ('Use LaTeX citations. '

          'Default: no, uses figures which might get mixed with images.',

          ['--use-latex-citations'],

          {'default': 0, 'action': 'store_true',

           'validator': frontend.validate_boolean}),

         ('Format for block quote attributions: one of "dash" (em-dash '

          'prefix), "parentheses"/"parens", or "none".  Default is "dash".',

          ['--attribution'],

          {'choices': ['dash', 'parentheses', 'parens', 'none'],

           'default': 'dash', 'metavar': '<format>'}),

         ('Specify a stylesheet file. The file will be "input" by latex in '

          'the document header.  Default is no stylesheet ("").  '

          'Overrides --stylesheet-path.',

          ['--stylesheet'],

          {'default': '', 'metavar': '<file>',

           'overrides': 'stylesheet_path'}),

         ('Specify a stylesheet file, relative to the current working '

          'directory.  Overrides --stylesheet.',

          ['--stylesheet-path'],

          {'metavar': '<file>', 'overrides': 'stylesheet'}),

         ('Table of contents by docutils (default) or LaTeX. LaTeX (writer) '

          'supports only one ToC per document, but docutils does not know of '

          'pagenumbers. LaTeX table of contents also means LaTeX generates '

          'sectionnumbers.',

          ['--use-latex-toc'],

          {'default': 0, 'action': 'store_true',

           'validator': frontend.validate_boolean}),

         ('Add parts on top of the section hierarchy.',

          ['--use-part-section'],

          {'default': 0, 'action': 'store_true',

           'validator': frontend.validate_boolean}),

         ('Let LaTeX print author and date, do not show it in docutils '

          'document info.',

          ['--use-latex-docinfo'],

          {'default': 0, 'action': 'store_true',

           'validator': frontend.validate_boolean}),

         ('Use LaTeX abstract environment for the documents abstract.'

          'Per default the abstract is an unnumbered section.',

          ['--use-latex-abstract'],

          {'default': 0, 'action': 'store_true',

           'validator': frontend.validate_boolean}),

         ('Color of any hyperlinks embedded in text '

          '(default: "blue", "0" to disable).',

          ['--hyperlink-color'], {'default': 'blue'}),

         ('Enable compound enumerators for nested enumerated lists '

          '(e.g. "1.2.a.ii").  Default: disabled.',

          ['--compound-enumerators'],

          {'default': None, 'action': 'store_true',

           'validator': frontend.validate_boolean}),

         ('Disable compound enumerators for nested enumerated lists.  This is '

          'the default.',

          ['--no-compound-enumerators'],

          {'action': 'store_false', 'dest': 'compound_enumerators'}),

         ('Enable section ("." subsection ...) prefixes for compound '

          'enumerators.  This has no effect without --compound-enumerators.  '

          'Default: disabled.',

          ['--section-prefix-for-enumerators'],

          {'default': None, 'action': 'store_true',

           'validator': frontend.validate_boolean}),

         ('Disable section prefixes for compound enumerators.  '

          'This is the default.',

          ['--no-section-prefix-for-enumerators'],

          {'action': 'store_false', 'dest': 'section_prefix_for_enumerators'}),

         ('Set the separator between section number and enumerator '

          'for compound enumerated lists.  Default is "-".',

          ['--section-enumerator-separator'],

          {'default': '-', 'metavar': '<char>'}),

         ('When possibile, use verbatim for literal-blocks. '

          'Default is to always use the mbox environment.',

          ['--use-verbatim-when-possible'],

          {'default': 0, 'action': 'store_true',

           'validator': frontend.validate_boolean}),

         ('Table style. "standard" with horizontal and vertical lines, '

          '"booktabs" (LaTeX booktabs style) only horizontal lines '

          'above and below the table and below the header or "nolines".  '

          'Default: "standard"',

          ['--table-style'],

          {'choices': ['standard', 'booktabs','nolines'], 'default': 'standard',

           'metavar': '<format>'}),

         ('LaTeX graphicx package option. '

          'Possible values are "dvips", "pdftex". "auto" includes LaTeX code '

          'to use "pdftex" if processing with pdf(la)tex and dvips otherwise. '

          'Default is no option.',

          ['--graphicx-option'],

          {'default': ''}),

         ('LaTeX font encoding. '

          'Possible values are "T1", "OT1", "" or some other fontenc option. '

          'The font encoding influences available symbols, e.g. "<<" as one '

          'character. Default is "" which leads to package "ae" (a T1 '

          'emulation using CM fonts).',

          ['--font-encoding'],

          {'default': ''}),

         ('Per default the latex-writer puts the reference title into '

          'hyperreferences. Specify "ref*" or "pageref*" to get the section '

          'number or the page number.',

          ['--reference-label'],

          {'default': None, }),

         ('Specify style and database for bibtex, for example '

          '"--use-bibtex=mystyle,mydb1,mydb2".',

          ['--use-bibtex'],

          {'default': None, }),

          ),)

    settings_defaults = {'output_encoding': 'latin-1'}

    relative_path_settings = ('stylesheet_path',)

    config_section = 'latex2e writer'

    config_section_dependencies = ('writers',)

    visitor_attributes = ("head_prefix", "head", 

            "body_prefix", "body", "body_suffix")

    output = None

    """Final translated form of `document`."""

    def __init__(self):

        writers.Writer.__init__(self)

        self.translator_class = LaTeXTranslator

    def translate(self):

        visitor = self.translator_class(self.document)

        self.document.walkabout(visitor)

        self.output = visitor.astext()

        # copy parts 

        for attr in self.visitor_attributes:

            setattr(self, attr, getattr(visitor, attr))

    def assemble_parts(self):

        writers.Writer.assemble_parts(self)

        for part in self.visitor_attributes:

            self.parts[part] = ''.join(getattr(self, part))

"""

Notes on LaTeX

--------------

* LaTeX does not support multiple tocs in one document.

  (might be no limitation except for docutils documentation)

  The "minitoc" latex package can produce per-chapter tocs in

  book and report document classes.

* width

  * linewidth - width of a line in the local environment

  * textwidth - the width of text on the page

  Maybe always use linewidth ?

  *Bug* inside a minipage a (e.g. Sidebar) the linewidth is

        not changed, needs fix in docutils so that tables

        are not too wide.

        So we add locallinewidth set it initially and

        on entering sidebar and reset on exit.

"""

class Babel:

    """Language specifics for LaTeX."""

    # country code by a.schlock.

    # partly manually converted from iso and babel stuff, dialects and some

    _ISO639_TO_BABEL = {

        'no': 'norsk',     #XXX added by hand ( forget about nynorsk?)

        'gd': 'scottish',  #XXX added by hand

        'hu': 'magyar',    #XXX added by hand

        'pt': 'portuguese',#XXX added by hand

        'sl': 'slovenian',

        'af': 'afrikaans',

        'bg': 'bulgarian',

        'br': 'breton',

        'ca': 'catalan',

        'cs': 'czech',

        'cy': 'welsh',

        'da': 'danish',

        'fr': 'french',

        # french, francais, canadien, acadian

        'de': 'ngerman',  #XXX rather than german

        # ngerman, naustrian, german, germanb, austrian

        'el': 'greek',

        'en': 'english',

        # english, USenglish, american, UKenglish, british, canadian

        'eo': 'esperanto',

        'es': 'spanish',

        'et': 'estonian',

        'eu': 'basque',

        'fi': 'finnish',

        'ga': 'irish',

        'gl': 'galician',

        'he': 'hebrew',

        'hr': 'croatian',

        'hu': 'hungarian',

        'is': 'icelandic',

        'it': 'italian',

        'la': 'latin',

        'nl': 'dutch',

        'pl': 'polish',

        'pt': 'portuguese',

        'ro': 'romanian',

        'ru': 'russian',

        'sk': 'slovak',

        'sr': 'serbian',

        'sv': 'swedish',

        'tr': 'turkish',

        'uk': 'ukrainian'

    }

    def __init__(self,lang):

        self.language = lang

        # pdflatex does not produce double quotes for ngerman in tt.

        self.double_quote_replacment = None

        if re.search('^de',self.language):

            #self.quotes = ("\"`", "\"'")

            self.quotes = ('{\\glqq}', '{\\grqq}')

            self.double_quote_replacment = "{\\dq}"

        elif re.search('^it',self.language):

            self.quotes = ("``", "''")

            self.double_quote_replacment = r'{\char`\"}'

        else:

            self.quotes = ("``", "''")

        self.quote_index = 0

    def next_quote(self):

        q = self.quotes[self.quote_index]

        self.quote_index = (self.quote_index+1)%2

        return q

    def quote_quotes(self,text):

        t = None

        for part in text.split('"'):

            if t == None:

                t = part

            else:

                t += self.next_quote() + part

        return t

    def double_quotes_in_tt (self,text):

        if not self.double_quote_replacment:

            return text

        return text.replace('"', self.double_quote_replacment)

    def get_language(self):

        if self._ISO639_TO_BABEL.has_key(self.language):

            return self._ISO639_TO_BABEL[self.language]

        else:

            # support dialects.

            l = self.language.split("_")[0]

            if self._ISO639_TO_BABEL.has_key(l):

                return self._ISO639_TO_BABEL[l]

        return None

latex_headings = {

        'optionlist_environment' : [

              '\\newcommand{\\optionlistlabel}[1]{\\bf #1 \\hfill}\n'

              '\\newenvironment{optionlist}[1]\n'

              '{\\begin{list}{}\n'

              '  {\\setlength{\\labelwidth}{#1}\n'

              '   \\setlength{\\rightmargin}{1cm}\n'

              '   \\setlength{\\leftmargin}{\\rightmargin}\n'

              '   \\addtolength{\\leftmargin}{\\labelwidth}\n'

              '   \\addtolength{\\leftmargin}{\\labelsep}\n'

              '   \\renewcommand{\\makelabel}{\\optionlistlabel}}\n'

              '}{\\end{list}}\n',

              ],

        'lineblock_environment' : [

            '\\newlength{\\lineblockindentation}\n'

            '\\setlength{\\lineblockindentation}{2.5em}\n'

            '\\newenvironment{lineblock}[1]\n'

            '{\\begin{list}{}\n'

            '  {\\setlength{\\partopsep}{\\parskip}\n'

            '   \\addtolength{\\partopsep}{\\baselineskip}\n'

            '   \\topsep0pt\\itemsep0.15\\baselineskip\\parsep0pt\n'

            '   \\leftmargin#1}\n'

            ' \\raggedright}\n'

            '{\\end{list}}\n'

            ],

        'footnote_floats' : [

            '% begin: floats for footnotes tweaking.\n',

            '\\setlength{\\floatsep}{0.5em}\n',

            '\\setlength{\\textfloatsep}{\\fill}\n',

            '\\addtolength{\\textfloatsep}{3em}\n',

            '\\renewcommand{\\textfraction}{0.5}\n',

            '\\renewcommand{\\topfraction}{0.5}\n',

            '\\renewcommand{\\bottomfraction}{0.5}\n',

            '\\setcounter{totalnumber}{50}\n',

            '\\setcounter{topnumber}{50}\n',

            '\\setcounter{bottomnumber}{50}\n',

            '% end floats for footnotes\n',

            ],

        'some_commands' : [

            '% some commands, that could be overwritten in the style file.\n'

            '\\newcommand{\\rubric}[1]'

            '{\\subsection*{~\\hfill {\\it #1} \\hfill ~}}\n'

            '\\newcommand{\\titlereference}[1]{\\textsl{#1}}\n'

            '% end of "some commands"\n',

            ]

        }

class DocumentClass:

    """Details of a LaTeX document class."""

    def __init__(self, document_class, with_part=False):

        self.document_class = document_class

        self._with_part = with_part

    def section(self, level):

        """ Return the section name at the given level for the specific

            document class.

            Level is 1,2,3..., as level 0 is the title."""

        sections = [ 'section', 'subsection', 'subsubsection', 

                     'paragraph', 'subparagraph' ]

        if self.document_class in ('book', 'report', 'scrreprt', 'scrbook'):

            sections.insert(0, 'chapter')

        if self._with_part:

            sections.insert(0, 'part')

        if level <= len(sections):

            return sections[level-1]

        else:

            return sections[-1]

class Table:

    """ Manage a table while traversing.

        Maybe change to a mixin defining the visit/departs, but then

        class Table internal variables are in the Translator.

        Table style might be 

        * standard: horizontal and vertical lines

        * booktabs (requires booktabs latex package): only horizontal lines

        * nolines, borderless : no lines

    """

    def __init__(self,latex_type,table_style):

        self._latex_type = latex_type

        self._table_style = table_style

        self._open = 0

        # miscellaneous attributes

        self._attrs = {}

        self._col_width = []

        self._rowspan = []

        self.stubs = []

    def open(self):

        self._open = 1

        self._col_specs = []

        self.caption = None

        self._attrs = {}

        self._in_head = 0 # maybe context with search

    def close(self):

        self._open = 0

        self._col_specs = None

        self.caption = None

        self._attrs = {}

        self.stubs = []

    def is_open(self):

        return self._open

    def set_table_style(self, table_style):

        if not table_style in ('standard','booktabs','borderless','nolines'):

            return

        self._table_style = table_style

    def used_packages(self):

        if self._table_style == 'booktabs':

            return '\\usepackage{booktabs}\n'

        return ''

    def get_latex_type(self):

        return self._latex_type

    def set(self,attr,value):

        self._attrs[attr] = value

    def get(self,attr):

        if self._attrs.has_key(attr):

            return self._attrs[attr]

        return None

    def get_vertical_bar(self):

        if self._table_style == 'standard':

            return '|'

        return ''

    # horizontal lines are drawn below a row, because we.

    def get_opening(self):

        if self._latex_type == 'longtable':

            # otherwise longtable might move before paragraph and subparagraph

            prefix = '\\leavevmode\n'

        else:

            prefix = ''

        return '%s\\begin{%s}[c]' % (prefix, self._latex_type)

    def get_closing(self):

        line = ""

        if self._table_style == 'booktabs':

            line = '\\bottomrule\n'

        elif self._table_style == 'standard':

            lines = '\\hline\n'

        return '%s\\end{%s}' % (line,self._latex_type)

    def visit_colspec(self, node):

        self._col_specs.append(node)

        # "stubs" list is an attribute of the tgroup element:

        self.stubs.append(node.attributes.get('stub'))

    def get_colspecs(self):

        """

        Return column specification for longtable.

        Assumes reST line length being 80 characters.

        Table width is hairy.

        === ===

        ABC DEF

        === ===

        usually gets to narrow, therefore we add 1 (fiddlefactor).

        """

        width = 80

        total_width = 0.0

        # first see if we get too wide.

        for node in self._col_specs:

            colwidth = float(node['colwidth']+1) / width

            total_width += colwidth

        self._col_width = []

        self._rowspan = []

        # donot make it full linewidth

        factor = 0.93

        if total_width > 1.0:

            factor /= total_width

        bar = self.get_vertical_bar()

        latex_table_spec = ""

        for node in self._col_specs:

            colwidth = factor * float(node['colwidth']+1) / width

            self._col_width.append(colwidth+0.005)

            self._rowspan.append(0)

            latex_table_spec += "%sp{%.3f\\locallinewidth}" % (bar,colwidth+0.005)

        return latex_table_spec+bar

    def get_column_width(self):

        """ return columnwidth for current cell (not multicell)

        """

        return "%.2f\\locallinewidth" % self._col_width[self._cell_in_row-1]

    def visit_thead(self):

        self._in_thead = 1

        if self._table_style == 'standard':

            return ['\\hline\n']

        elif self._table_style == 'booktabs':

            return ['\\toprule\n']

        return []

    def depart_thead(self):

        a = []

        #if self._table_style == 'standard':

        #    a.append('\\hline\n')

        if self._table_style == 'booktabs':

            a.append('\\midrule\n')

        if self._latex_type == 'longtable':

            a.append('\\endhead\n')

        # for longtable one could add firsthead, foot and lastfoot

        self._in_thead = 0

        return a

    def visit_row(self):

        self._cell_in_row = 0

    def depart_row(self):

        res = [' \\\\\n']

        self._cell_in_row = None  # remove cell counter

        for i in range(len(self._rowspan)):

            if (self._rowspan[i]>0):

                self._rowspan[i] -= 1

        if self._table_style == 'standard':

            rowspans = []

            for i in range(len(self._rowspan)):

                if (self._rowspan[i]<=0):

                    rowspans.append(i+1)

            if len(rowspans)==len(self._rowspan):

                res.append('\\hline\n')

            else: