PageRenderTime 65ms CodeModel.GetById 14ms RepoModel.GetById 0ms app.codeStats 1ms

/sandbox/rst2context/context/__init__.py

https://bitbucket.org/mirror/docutils
Python | 3049 lines | 3006 code | 10 blank | 33 comment | 7 complexity | d03c58fb861dfc4bbb244889ca5878f2 MD5 | raw file
Possible License(s): Apache-2.0, BSD-2-Clause, GPL-3.0, GPL-2.0, MIT 
    

  1. # .. coding: utf8
    2. 

  2. # $Id$
    3. 

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

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

  5. 

  6. """ConTeXt document tree Writer."""
    7. 

  7. 

  8. __docformat__ = 'reStructuredText'
    9. 

  9. 

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

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

  12. #
    13. 

  13. # convention deactivate code by two # i.e. ##.
    14. 

  14. 

  15. import sys
    16. 

  16. import os
    17. 

  17. import time
    18. 

  18. import re
    19. 

  19. import string
    20. 

  20. import urllib
    21. 

  21. from docutils import frontend, nodes, languages, writers, utils, io
    22. 

  22. from docutils.transforms import writer_aux
    23. 

  23. from docutils.math import pick_math_environment, unichar2tex
    24. 

  24. 

  25. # compatibility module for Python 2.3
    26. 

  26. if not hasattr(string, 'Template'):
    27. 

  27.     import docutils._string_template_compat
    28. 

  28.     string.Template = docutils._string_template_compat.Template
    29. 

  29. 

  30. class Writer(writers.Writer):
    31. 

  31. 

  32.     supported = ('context',)
    33. 

  33.     """Formats this writer supports."""
    34. 

  34. 

  35.     default_template = 'default.tex'
    36. 

  36.     default_template_path = os.path.dirname(__file__)
    37. 

  37. 

  38.     default_preamble = '\n'.join([r'% PDF Standard Fonts',
    39. 

  39.                                   r'\usepackage{mathptmx} % Times',
    40. 

  40.                                   r'\usepackage[scaled=.90]{helvet}',
    41. 

  41.                                   r'\usepackage{courier}'])
    42. 

  42.     settings_spec = (
    43. 

  43.         'LaTeX-Specific Options',
    44. 

  44.         None,
    45. 

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

  46.           ['--documentclass'],
    47. 

  47.           {'default': 'article', }),
    48. 

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

  49.           'separated by commas.  Default is "a4paper".',
    50. 

  50.           ['--documentoptions'],
    51. 

  51.           {'default': 'a4paper', }),
    52. 

  52.          ('Footnotes with numbers/symbols by Docutils. (default)',
    53. 

  53.           ['--docutils-footnotes'],
    54. 

  54.           {'default': True, 'action': 'store_true',
    55. 

  55.            'validator': frontend.validate_boolean}),
    56. 

  56.          ('Alias for --docutils-footnotes (deprecated)',
    57. 

  57.           ['--use-latex-footnotes'],
    58. 

  58.           {'action': 'store_true',
    59. 

  59.            'validator': frontend.validate_boolean}),
    60. 

  60.          ('Use figure floats for footnote text (deprecated)',
    61. 

  61.           ['--figure-footnotes'],
    62. 

  62.           {'action': 'store_true',
    63. 

  63.            'validator': frontend.validate_boolean}),
    64. 

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

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

  66.           ['--footnote-references'],
    67. 

  67.           {'choices': ['superscript', 'brackets'], 'default': 'superscript',
    68. 

  68.            'metavar': '<format>',
    69. 

  69.            'overrides': 'trim_footnote_reference_space'}),
    70. 

  70.          ('Use \\cite command for citations. ',
    71. 

  71.           ['--use-latex-citations'],
    72. 

  72.           {'default': 0, 'action': 'store_true',
    73. 

  73.            'validator': frontend.validate_boolean}),
    74. 

  74.          ('Use figure floats for citations '
    75. 

  75.           '(might get mixed with real figures). (default)',
    76. 

  76.           ['--figure-citations'],
    77. 

  77.           {'dest': 'use_latex_citations', 'action': 'store_false',
    78. 

  78.            'validator': frontend.validate_boolean}),
    79. 

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

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

  81.           ['--attribution'],
    82. 

  82.           {'choices': ['dash', 'parentheses', 'parens', 'none'],
    83. 

  83.            'default': 'dash', 'metavar': '<format>'}),
    84. 

  84.          ('Specify LaTeX packages/stylesheets. '
    85. 

  85.          ' A style is referenced with \\usepackage if extension is '
    86. 

  86.          '".sty" or omitted and with \\input else. '
    87. 

  87.           ' Overrides previous --stylesheet and --stylesheet-path settings.',
    88. 

  88.           ['--stylesheet'],
    89. 

  89.           {'default': '', 'metavar': '<file>',
    90. 

  90.            'overrides': 'stylesheet_path'}),
    91. 

  91.          ('Like --stylesheet, but the path is rewritten '
    92. 

  92.           'relative to the output file. ',
    93. 

  93.           ['--stylesheet-path'],
    94. 

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

  95.          ('Link to the stylesheet(s) in the output file. (default)',
    96. 

  96.           ['--link-stylesheet'],
    97. 

  97.           {'dest': 'embed_stylesheet', 'action': 'store_false'}),
    98. 

  98.          ('Embed the stylesheet(s) in the output file. '
    99. 

  99.           'Stylesheets must be accessible during processing. ',
    100. 

  100.           ['--embed-stylesheet'],
    101. 

  101.           {'default': 0, 'action': 'store_true',
    102. 

  102.            'validator': frontend.validate_boolean}),
    103. 

  103.          ('Customization by LaTeX code in the preamble. '
    104. 

  104.           'Default: select PDF standard fonts (Times, Helvetica, Courier).',
    105. 

  105.           ['--context-preamble'],
    106. 

  106.           {'default': default_preamble}),
    107. 

  107.          ('Specify the template file. Default: "%s".' % default_template,
    108. 

  108.           ['--template'],
    109. 

  109.           {'default': default_template, 'metavar': '<file>'}),
    110. 

  110.          ('Table of contents by LaTeX. (default) ',
    111. 

  111.           ['--use-latex-toc'],
    112. 

  112.           {'default': 1, 'action': 'store_true',
    113. 

  113.            'validator': frontend.validate_boolean}),
    114. 

  114.          ('Table of contents by Docutils (without page numbers). ',
    115. 

  115.           ['--use-docutils-toc'],
    116. 

  116.           {'dest': 'use_latex_toc', 'action': 'store_false',
    117. 

  117.            'validator': frontend.validate_boolean}),
    118. 

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

  119.           ['--use-part-section'],
    120. 

  120.           {'default': 0, 'action': 'store_true',
    121. 

  121.            'validator': frontend.validate_boolean}),
    122. 

  122.          ('Attach author and date to the document info table. (default) ',
    123. 

  123.           ['--use-docutils-docinfo'],
    124. 

  124.           {'dest': 'use_latex_docinfo', 'action': 'store_false',
    125. 

  125.            'validator': frontend.validate_boolean}),
    126. 

  126.          ('Attach author and date to the document title.',
    127. 

  127.           ['--use-latex-docinfo'],
    128. 

  128.           {'default': 0, 'action': 'store_true',
    129. 

  129.            'validator': frontend.validate_boolean}),
    130. 

  130.          ("Typeset abstract as topic. (default)",
    131. 

  131.           ['--topic-abstract'],
    132. 

  132.           {'dest': 'use_latex_abstract', 'action': 'store_false',
    133. 

  133.            'validator': frontend.validate_boolean}),
    134. 

  134.          ("Use LaTeX abstract environment for the document's abstract. ",
    135. 

  135.           ['--use-latex-abstract'],
    136. 

  136.           {'default': 0, 'action': 'store_true',
    137. 

  137.            'validator': frontend.validate_boolean}),
    138. 

  138.          ('Color of any hyperlinks embedded in text '
    139. 

  139.           '(default: "blue", "false" to disable).',
    140. 

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

  141.          ('Additional options to the "hyperref" package '
    142. 

  142.           '(default: "").',
    143. 

  143.           ['--hyperref-options'], {'default': ''}),
    144. 

  144.          ('Enable compound enumerators for nested enumerated lists '
    145. 

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

  146.           ['--compound-enumerators'],
    147. 

  147.           {'default': None, 'action': 'store_true',
    148. 

  148.            'validator': frontend.validate_boolean}),
    149. 

  149.          ('Disable compound enumerators for nested enumerated lists. '
    150. 

  150.           'This is the default.',
    151. 

  151.           ['--no-compound-enumerators'],
    152. 

  152.           {'action': 'store_false', 'dest': 'compound_enumerators'}),
    153. 

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

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

  155.           'Default: disabled.',
    156. 

  156.           ['--section-prefix-for-enumerators'],
    157. 

  157.           {'default': None, 'action': 'store_true',
    158. 

  158.            'validator': frontend.validate_boolean}),
    159. 

  159.          ('Disable section prefixes for compound enumerators.  '
    160. 

  160.           'This is the default.',
    161. 

  161.           ['--no-section-prefix-for-enumerators'],
    162. 

  162.           {'action': 'store_false', 'dest': 'section_prefix_for_enumerators'}),
    163. 

  163.          ('Set the separator between section number and enumerator '
    164. 

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

  165.           ['--section-enumerator-separator'],
    166. 

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

  167.          ('When possibile, use the specified environment for literal-blocks. '
    168. 

  168.           'Default is quoting of whitespace and special chars.',
    169. 

  169.           ['--literal-block-env'],
    170. 

  170.           {'default': ''}),
    171. 

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

  172.           'Compatibility alias for "--literal-block-env=verbatim".',
    173. 

  173.           ['--use-verbatim-when-possible'],
    174. 

  174.           {'default': 0, 'action': 'store_true',
    175. 

  175.            'validator': frontend.validate_boolean}),
    176. 

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

  177.           '"booktabs" (LaTeX booktabs style) only horizontal lines '
    178. 

  178.           'above and below the table and below the header or "borderless".  '
    179. 

  179.           'Default: "standard"',
    180. 

  180.           ['--table-style'],
    181. 

  181.           {'choices': ['standard', 'booktabs','nolines', 'borderless'],
    182. 

  182.            'default': 'standard',
    183. 

  183.            'metavar': '<format>'}),
    184. 

  184.          ('LaTeX graphicx package option. '
    185. 

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

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

  187.           'Default is no option.',
    188. 

  188.           ['--graphicx-option'],
    189. 

  189.           {'default': ''}),
    190. 

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

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

  192.           'number or the page number.',
    193. 

  193.           ['--reference-label'],
    194. 

  194.           {'default': None, }),
    195. 

  195.          ('Specify style and database for bibtex, for example '
    196. 

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

  197.           ['--use-bibtex'],
    198. 

  198.           {'default': None, }),
    199. 

  199.           ),)
    200. 

  200. 

  201.     settings_defaults = {'sectnum_depth': 0 # updated by SectNum transform
    202. 

  202.                         }
    203. 

  203.     relative_path_settings = ('stylesheet_path',)
    204. 

  204. 

  205.     config_section = 'context writer'
    206. 

  206.     config_section_dependencies = ('writers',)
    207. 

  207. 

  208.     head_parts = ('head_prefix', 'requirements', 'context_preamble', 'latex_preamble', 
    209. 

  209.                   'stylesheet', 'fallbacks', 'pdfsetup',
    210. 

  210.                   'title', 'subtitle', 'titledata')
    211. 

  211.     visitor_attributes = head_parts + ('body_pre_docinfo', 'docinfo',
    212. 

  212.                                        'dedication', 'abstract', 'body')
    213. 

  213. 

  214.     output = None
    215. 

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

  216. 

  217.     def __init__(self):
    218. 

  218.         writers.Writer.__init__(self)
    219. 

  219.         self.translator_class = LaTeXTranslator
    220. 

  220. 

  221.     # Override parent method to add latex-specific transforms
    222. 

  222.     def get_transforms(self):
    223. 

  223.        # call the parent class' method
    224. 

  224.        transform_list = writers.Writer.get_transforms(self)
    225. 

  225.        # print transform_list
    226. 

  226.        # Convert specific admonitions to generic one
    227. 

  227.        transform_list.append(writer_aux.Admonitions)
    228. 

  228.        # TODO: footnote collection transform
    229. 

  229.        # transform_list.append(footnotes.collect)
    230. 

  230.        return transform_list
    231. 

  231. 

  232.     def translate(self):
    233. 

  233.         visitor = self.translator_class(self.document)
    234. 

  234.         self.document.walkabout(visitor)
    235. 

  235.         # copy parts
    236. 

  236.         for part in self.visitor_attributes:
    237. 

  237.             setattr(self, part, getattr(visitor, part))
    238. 

  238.         # get template string from file
    239. 

  239.         try:
    240. 

  240.             template_file = open(self.document.settings.template, 'rb')
    241. 

  241.         except IOError:
    242. 

  242.             template_file = open(os.path.join(self.default_template_path,
    243. 

  243.                                      self.document.settings.template), 'rb')
    244. 

  244.         template = string.Template(unicode(template_file.read(), 'utf-8'))
    245. 

  245.         template_file.close()
    246. 

  246.         # fill template
    247. 

  247.         self.assemble_parts() # create dictionary of parts
    248. 

  248.         self.output = template.substitute(self.parts)
    249. 

  249. 

  250.     def assemble_parts(self):
    251. 

  251.         """Assemble the `self.parts` dictionary of output fragments."""
    252. 

  252.         writers.Writer.assemble_parts(self)
    253. 

  253. 

  254.         for part in self.visitor_attributes:
    255. 

  255.             lines = getattr(self, part)
    256. 

  256.             # Temporary!!! -- disable requirements
    257. 

  257.             if part in self.head_parts and not 'requirements':
    258. 

  258.                 if lines:
    259. 

  259.                     lines.append('') # to get a trailing newline
    260. 

  260.                 self.parts[part] = '\n'.join(lines)
    261. 

  261.             else:
    262. 

  262.                 # body contains inline elements, so join without newline
    263. 

  263.                 self.parts[part] = ''.join(lines)
    264. 

  264. 

  265. 

  266. class Babel(object):
    267. 

  267.     """Language specifics for LaTeX."""
    268. 

  268. 

  269.     # TeX (babel) language names:
    270. 

  270.     # ! not all of these are supported by Docutils!
    271. 

  271.     #
    272. 

  272.     # based on LyX' languages file with adaptions to `BCP 47`_
    273. 

  273.     # (http://www.rfc-editor.org/rfc/bcp/bcp47.txt) and
    274. 

  274.     # http://www.tug.org/TUGboat/Articles/tb29-3/tb93miklavec.pdf
    275. 

  275.     # * the key without subtags is the default
    276. 

  276.     # * case is ignored
    277. 

  277.     # cf. http://docutils.sourceforge.net/docs/howto/i18n.html
    278. 

  278.     #     http://www.w3.org/International/articles/language-tags/
    279. 

  279.     # and http://www.iana.org/assignments/language-subtag-registry
    280. 

  280.     language_codes = {
    281. 

  281.         # code          TeX/Babel-name       comment
    282. 

  282.         'af':           'afrikaans',
    283. 

  283.         'ar':           'arabic',
    284. 

  284.         # 'be':           'belarusian',
    285. 

  285.         'bg':           'bulgarian',
    286. 

  286.         'br':           'breton',
    287. 

  287.         'ca':           'catalan',
    288. 

  288.         # 'cop':          'coptic',
    289. 

  289.         'cs':           'czech',
    290. 

  290.         'cy':           'welsh',
    291. 

  291.         'da':           'danish',
    292. 

  292.         'de':           'ngerman', # new spelling (de_1996)
    293. 

  293.         'de_1901':      'german', # old spelling
    294. 

  294.         'de_at':        'naustrian',
    295. 

  295.         'de_at_1901':   'austrian',
    296. 

  296.         'dsb':          'lowersorbian',
    297. 

  297.         'el':           'greek', # monotonic (el-monoton)
    298. 

  298.         'el_polyton':   'polutonikogreek',
    299. 

  299.         'en':           'english',  # TeX' default language
    300. 

  300.         'en_au':        'australian',
    301. 

  301.         'en_ca':        'canadian',
    302. 

  302.         'en_gb':        'british',
    303. 

  303.         'en_nz':        'newzealand',
    304. 

  304.         'en_us':        'american',
    305. 

  305.         'eo':           'esperanto', # '^' is active
    306. 

  306.         'es':           'spanish',
    307. 

  307.         'et':           'estonian',
    308. 

  308.         'eu':           'basque',
    309. 

  309.         # 'fa':           'farsi',
    310. 

  310.         'fi':           'finnish',
    311. 

  311.         'fr':           'french',
    312. 

  312.         'fr_ca':        'canadien',
    313. 

  313.         'ga':           'irish',    # Irish Gaelic
    314. 

  314.         # 'grc':                    # Ancient Greek
    315. 

  315.         'grc_ibycus':   'ibycus',   # Ibycus encoding
    316. 

  316.         'gl':           'galician',
    317. 

  317.         'he':           'hebrew',
    318. 

  318.         'hr':           'croatian',
    319. 

  319.         'hsb':          'uppersorbian',
    320. 

  320.         'hu':           'magyar',
    321. 

  321.         'ia':           'interlingua',
    322. 

  322.         'id':           'bahasai',  # Bahasa (Indonesian)
    323. 

  323.         'is':           'icelandic',
    324. 

  324.         'it':           'italian',
    325. 

  325.         'ja':           'japanese',
    326. 

  326.         'kk':           'kazakh',
    327. 

  327.         'la':           'latin',
    328. 

  328.         'lt':           'lithuanian',
    329. 

  329.         'lv':           'latvian',
    330. 

  330.         'mn':           'mongolian', # Mongolian, Cyrillic script (mn-cyrl)
    331. 

  331.         'ms':           'bahasam',   # Bahasa (Malay)
    332. 

  332.         'nb':           'norsk',     # Norwegian Bokmal
    333. 

  333.         'nl':           'dutch',
    334. 

  334.         'nn':           'nynorsk',   # Norwegian Nynorsk
    335. 

  335.         'no':           'norsk',     # Norwegian Bokmal
    336. 

  336.         'pl':           'polish',
    337. 

  337.         'pt':           'portuges',
    338. 

  338.         'pt_br':        'brazil',
    339. 

  339.         'ro':           'romanian',
    340. 

  340.         'ru':           'russian',   # '"' is active
    341. 

  341.         'se':           'samin',     # North Sami
    342. 

  342.         # sh-cyrl:      Serbo-Croatian, Cyrillic script
    343. 

  343.         'sh-latn':      'serbian', # Serbo-Croatian, Latin script
    344. 

  344.         'sk':           'slovak',
    345. 

  345.         'sl':           'slovene',
    346. 

  346.         'sq':           'albanian',
    347. 

  347.         # 'sr-cyrl':    Serbian, Cyrillic script (sr-cyrl)
    348. 

  348.         'sr-latn':      'serbian', # Serbian, Latin script, " active.
    349. 

  349.         'sv':           'swedish',
    350. 

  350.         # 'th':           'thai',
    351. 

  351.         'tr':           'turkish',
    352. 

  352.         'uk':           'ukrainian',
    353. 

  353.         'vi':           'vietnam',
    354. 

  354.         # zh-latn:      Chinese Pinyin
    355. 

  355.         }
    356. 

  356.     warn_msg = 'Language "%s" not supported by LaTeX (babel)'
    357. 

  357. 

  358.     def __init__(self, language_code, reporter=None):
    359. 

  359.         self.reporter = reporter
    360. 

  360.         self.language = self.language_name(language_code)
    361. 

  361.         self.otherlanguages = {}
    362. 

  362.         self.quote_index = 0
    363. 

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

  364.         # language dependent configuration:
    365. 

  365.         # double quotes are "active" in some languages (e.g. German).
    366. 

  366.         self.literal_double_quote = u'"'
    367. 

  367.         if self.language in ('ngerman', 'german', 'austrian', 'naustrian',
    368. 

  368.                              'russian'):
    369. 

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

  370.             self.literal_double_quote = ur'\dq{}'
    371. 

  371.         if self.language == 'french':
    372. 

  372.             self.quotes = (r'\og{}', r'\fg{}')
    373. 

  373.         if self.language == 'italian':
    374. 

  374.             self.literal_double_quote = ur'{\char`\"}'
    375. 

  375. 

  376.     def __call__(self):
    377. 

  377.         """Return the babel call with correct options and settings"""
    378. 

  378.         languages = self.otherlanguages.keys()
    379. 

  379.         languages.append(self.language or 'english')
    380. 

  380.         self.setup = [r'\usepackage[%s]{babel}' % ','.join(languages)]
    381. 

  381.         if 'spanish' in languages:
    382. 

  382.             # reset active chars to the original meaning:
    383. 

  383.             self.setup.append(
    384. 

  384.                 r'\addto\shorthandsspanish{\spanishdeactivate{."~<>}}')
    385. 

  385.             # or prepend r'\def\spanishoptions{es-noshorthands}'
    386. 

  386.         if (languages[-1] is 'english' and
    387. 

  387.             'french' in self.otherlanguages.keys()):
    388. 

  388.             self.setup += ['% Prevent side-effects if French hyphenation '
    389. 

  389.                            'patterns are not loaded:',
    390. 

  390.                            r'\frenchbsetup{StandardLayout}',
    391. 

  391.                            r'\AtBeginDocument{\selectlanguage{%s}'
    392. 

  392.                            r'\noextrasfrench}' % self.language]
    393. 

  393.         return '\n'.join(self.setup)
    394. 

  394. 

  395.     def next_quote(self):
    396. 

  396.         q = self.quotes[self.quote_index]
    397. 

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

  398.         return q
    399. 

  399. 

  400.     def quote_quotes(self,text):
    401. 

  401.         t = None
    402. 

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

  403.             if t == None:
    404. 

  404.                 t = part
    405. 

  405.             else:
    406. 

  406.                 t += self.next_quote() + part
    407. 

  407.         return t
    408. 

  408. 

  409.     def language_name(self, language_code):
    410. 

  410.         """Return TeX language name for `language_code`"""
    411. 

  411.         for tag in utils.normalize_language_tag(language_code):
    412. 

  412.             try:
    413. 

  413.                 return self.language_codes[tag]
    414. 

  414.             except KeyError:
    415. 

  415.                 pass
    416. 

  416.         if self.reporter is not None:
    417. 

  417.             self.reporter.warning(self.warn_msg % language_code)
    418. 

  418.         return ''
    419. 

  419. 

  420.     def get_language(self):
    421. 

  421.         """Return `self.language` (for backwards compatibility with Sphinx).
    422. 

  422.         """
    423. 

  423.         return self.language
    424. 

  424. 

  425. 

  426. # Building blocks for the context preamble
    427. 

  427. # --------------------------------------
    428. 

  428. 

  429. class SortableDict(dict):
    430. 

  430.     """Dictionary with additional sorting methods
    431. 

    432. 

  432.     Tip: use key starting with with '_' for sorting before small letters
    433. 

  433.          and with '~' for sorting after small letters.
    434. 

  434.     """
    435. 

  435.     def sortedkeys(self):
    436. 

  436.         """Return sorted list of keys"""
    437. 

  437.         keys = self.keys()
    438. 

  438.         keys.sort()
    439. 

  439.         return keys
    440. 

  440. 

  441.     def sortedvalues(self):
    442. 

  442.         """Return list of values sorted by keys"""
    443. 

  443.         return [self[key] for key in self.sortedkeys()]
    444. 

  444. 

  445. 

  446. # PreambleCmds
    447. 

  447. # `````````````
    448. 

  448. # A container for LaTeX code snippets that can be
    449. 

  449. # inserted into the preamble if required in the document.
    450. 

  450. #
    451. 

  451. # .. The package 'makecmds' would enable shorter definitions using the
    452. 

  452. #    \providelength and \provideenvironment commands.
    453. 

  453. #    However, it is pretty non-standard (texlive-latex-extra).
    454. 

    455. 

  455. class PreambleCmds(object):
    456. 

  456.     """Building blocks for the latex preamble."""
    457. 

    458. 

  458. PreambleCmds.abstract = r"""
    459. 

  459. % abstract title
    460. 

  460. \providecommand*{\DUtitleabstract}[1]{\centerline{{\bf #1}}}"""
    461. 

    462. 

  462. PreambleCmds.admonition = r"""
    463. 

  463. % admonition (specially marked topic)
    464. 

  464. \providecommand{\DUadmonition}[2][class-arg]{%
    465. 

  465.   % try \DUadmonition#1{#2}:
    466. 

  466.   \ifcsname DUadmonition#1\endcsname%
    467. 

  467.     \csname DUadmonition#1\endcsname{#2}%
    468. 

  468.   \else
    469. 

  469.     \begin{center}
    470. 

  470.       \fbox{\parbox{0.9\textwidth}{#2}}
    471. 

  471.     \end{center}
    472. 

  472.   \fi
    473. 

  473. }"""
    474. 

    475. 

  475. PreambleCmds.align_center = r"""
    476. 

  476. \makeatletter
    477. 

  477. \@namedef{DUrolealign-center}{\centering}
    478. 

  478. \makeatother
    479. 

  479. """
    480. 

    481. 

  481. ## PreambleCmds.caption = r"""% configure caption layout
    482. 

  482. ## \usepackage{caption}
    483. 

  483. ## \captionsetup{singlelinecheck=false}% no exceptions for one-liners"""
    484. 

    485. 

  485. PreambleCmds.color = r"""\usepackage{color}"""
    486. 

    487. 

  487. PreambleCmds.docinfo = r"""
    488. 

  488. % docinfo (width of docinfo table)
    489. 

  489. \DUprovidelength{\DUdocinfowidth}{0.9\textwidth}"""
    490. 

  490. # PreambleCmds.docinfo._depends = 'providelength'
    491. 

    492. 

  492. PreambleCmds.embedded_package_wrapper = r"""\makeatletter
    493. 

  493. %% embedded stylesheet: %s
    494. 

  494. %s
    495. 

  495. \makeatother"""
    496. 

    497. 

  497. PreambleCmds.dedication = r"""
    498. 

  498. % dedication topic
    499. 

  499. \providecommand{\DUtopicdedication}[1]{\begin{center}#1\end{center}}"""
    500. 

    501. 

  501. PreambleCmds.error = r"""
    502. 

  502. % error admonition title
    503. 

  503. \providecommand*{\DUtitleerror}[1]{\DUtitle{\color{red}#1}}"""
    504. 

  504. # PreambleCmds.errortitle._depends = 'color'
    505. 

    506. 

  506. PreambleCmds.fieldlist = r"""
    507. 

  507. % fieldlist environment
    508. 

  508. \ifthenelse{\isundefined{\DUfieldlist}}{
    509. 

  509.   \newenvironment{DUfieldlist}%
    510. 

  510.     {\quote\description}
    511. 

  511.     {\enddescription\endquote}
    512. 

  512. }{}"""
    513. 

    514. 

  514. PreambleCmds.float_settings = r"""\usepackage{float} % float configuration
    515. 

  515. \floatplacement{figure}{H} % place figures here definitely"""
    516. 

    517. 

  517. PreambleCmds.footnotes = r"""% numeric or symbol footnotes with hyperlinks
    518. 

  518. \providecommand*{\DUfootnotemark}[3]{%
    519. 

  519.   \raisebox{1em}{\hypertarget{#1}{}}%
    520. 

  520.   \hyperlink{#2}{\textsuperscript{#3}}%
    521. 

  521. }
    522. 

  522. \providecommand{\DUfootnotetext}[4]{%
    523. 

  523.   \begingroup%
    524. 

  524.   \renewcommand{\thefootnote}{%
    525. 

  525.     \protect\raisebox{1em}{\protect\hypertarget{#1}{}}%
    526. 

  526.     \protect\hyperlink{#2}{#3}}%
    527. 

  527.   \footnotetext{#4}%
    528. 

  528.   \endgroup%
    529. 

  529. }"""
    530. 

    531. 

  531. PreambleCmds.footnote_floats = r"""% settings for footnotes as floats:
    532. 

  532. \setlength{\floatsep}{0.5em}
    533. 

  533. \setlength{\textfloatsep}{\fill}
    534. 

  534. \addtolength{\textfloatsep}{3em}
    535. 

  535. \renewcommand{\textfraction}{0.5}
    536. 

  536. \renewcommand{\topfraction}{0.5}
    537. 

  537. \renewcommand{\bottomfraction}{0.5}
    538. 

  538. \setcounter{totalnumber}{50}
    539. 

  539. \setcounter{topnumber}{50}
    540. 

  540. \setcounter{bottomnumber}{50}"""
    541. 

    542. 

  542. PreambleCmds.graphicx_auto = r"""% Check output format
    543. 

  543. \ifx\pdftexversion\undefined
    544. 

  544.   \usepackage{graphicx}
    545. 

  545. \else
    546. 

  546.   \usepackage[pdftex]{graphicx}
    547. 

  547. \fi'))"""
    548. 

    549. 

  549. PreambleCmds.inline = r"""
    550. 

  550. % inline markup (custom roles)
    551. 

  551. % \DUrole{#1}{#2} tries \DUrole#1{#2}
    552. 

  552. \providecommand*{\DUrole}[2]{%
    553. 

  553.   \ifcsname DUrole#1\endcsname%
    554. 

  554.     \csname DUrole#1\endcsname{#2}%
    555. 

  555.   \else% backwards compatibility: try \docutilsrole#1{#2}
    556. 

  556.     \ifcsname docutilsrole#1\endcsname%
    557. 

  557.       \csname docutilsrole#1\endcsname{#2}%
    558. 

  558.     \else%
    559. 

  559.       #2%
    560. 

  560.     \fi%
    561. 

  561.   \fi%
    562. 

  562. }"""
    563. 

    564. 

  564. PreambleCmds.legend = r"""
    565. 

  565. % legend environment
    566. 

  566. \ifthenelse{\isundefined{\DUlegend}}{
    567. 

  567.   \newenvironment{DUlegend}{\small}{}
    568. 

  568. }{}"""
    569. 

    570. 

  570. PreambleCmds.lineblock = r"""
    571. 

  571. % lineblock environment
    572. 

  572. \DUprovidelength{\DUlineblockindent}{2.5em}
    573. 

  573. \ifthenelse{\isundefined{\DUlineblock}}{
    574. 

  574.   \newenvironment{DUlineblock}[1]{%
    575. 

  575.     \list{}{\setlength{\partopsep}{\parskip}
    576. 

  576.             \addtolength{\partopsep}{\baselineskip}
    577. 

  577.             \setlength{\topsep}{0pt}
    578. 

  578.             \setlength{\itemsep}{0.15\baselineskip}
    579. 

  579.             \setlength{\parsep}{0pt}
    580. 

  580.             \setlength{\leftmargin}{#1}}
    581. 

  581.     \raggedright
    582. 

  582.   }
    583. 

  583.   {\endlist}
    584. 

  584. }{}"""
    585. 

  585. # PreambleCmds.lineblock._depends = 'providelength'
    586. 

    587. 

  587. PreambleCmds.linking = r"""
    588. 

  588. %% hyperlinks:
    589. 

  589. \ifthenelse{\isundefined{\hypersetup}}{
    590. 

  590.   \usepackage[%s]{hyperref}
    591. 

  591.   \urlstyle{same} %% normal text font (alternatives: tt, rm, sf)
    592. 

  592. }{}"""
    593. 

    594. 

  594. PreambleCmds.minitoc = r"""%% local table of contents
    595. 

  595. \usepackage{minitoc}"""
    596. 

    597. 

  597. PreambleCmds.optionlist = r"""
    598. 

  598. % optionlist environment
    599. 

  599. \providecommand*{\DUoptionlistlabel}[1]{\bf #1 \hfill}
    600. 

  600. \DUprovidelength{\DUoptionlistindent}{3cm}
    601. 

  601. \ifthenelse{\isundefined{\DUoptionlist}}{
    602. 

  602.   \newenvironment{DUoptionlist}{%
    603. 

  603.     \list{}{\setlength{\labelwidth}{\DUoptionlistindent}
    604. 

  604.             \setlength{\rightmargin}{1cm}
    605. 

  605.             \setlength{\leftmargin}{\rightmargin}
    606. 

  606.             \addtolength{\leftmargin}{\labelwidth}
    607. 

  607.             \addtolength{\leftmargin}{\labelsep}
    608. 

  608.             \renewcommand{\makelabel}{\DUoptionlistlabel}}
    609. 

  609.   }
    610. 

  610.   {\endlist}
    611. 

  611. }{}"""
    612. 

  612. # PreambleCmds.optionlist._depends = 'providelength'
    613. 

    614. 

  614. PreambleCmds.providelength = r"""
    615. 

  615. % providelength (provide a length variable and set default, if it is new)
    616. 

  616. \providecommand*{\DUprovidelength}[2]{
    617. 

  617.   \ifthenelse{\isundefined{#1}}{\newlength{#1}\setlength{#1}{#2}}{}
    618. 

  618. }"""
    619. 

    620. 

  620. PreambleCmds.rubric = r"""
    621. 

  621. % rubric (informal heading)
    622. 

  622. \providecommand*{\DUrubric}[2][class-arg]{%
    623. 

  623.   \subsubsection*{\centering\textit{\textmd{#2}}}}"""
    624. 

    625. 

  625. PreambleCmds.sidebar = r"""
    626. 

  626. % sidebar (text outside the main text flow)
    627. 

  627. \providecommand{\DUsidebar}[2][class-arg]{%
    628. 

  628.   \begin{center}
    629. 

  629.     \colorbox[gray]{0.80}{\parbox{0.9\textwidth}{#2}}
    630. 

  630.   \end{center}
    631. 

  631. }"""
    632. 

    633. 

  633. PreambleCmds.subtitle = r"""
    634. 

  634. % subtitle (for topic/sidebar)
    635. 

  635. \providecommand*{\DUsubtitle}[2][class-arg]{\par\emph{#2}\smallskip}"""
    636. 

    637. 

  637. PreambleCmds.table = r"""\usepackage{longtable,ltcaption,array}
    638. 

  638. \setlength{\extrarowheight}{2pt}
    639. 

  639. \newlength{\DUtablewidth} % internal use in tables"""
    640. 

    641. 

  641. # Options [force,almostfull] prevent spurious error messages, see
    642. 

  642. # de.comp.text.tex/2005-12/msg01855
    643. 

  643. PreambleCmds.textcomp = """\
    644. 

  644. \\usepackage{textcomp} % text symbol macros"""
    645. 

    646. 

  646. PreambleCmds.titlereference = r"""
    647. 

  647. % titlereference role
    648. 

  648. \providecommand*{\DUroletitlereference}[1]{\textsl{#1}}"""
    649. 

    650. 

  650. PreambleCmds.title = r"""
    651. 

  651. % title for topics, admonitions and sidebar
    652. 

  652. \providecommand*{\DUtitle}[2][class-arg]{%
    653. 

  653.   % call \DUtitle#1{#2} if it exists:
    654. 

  654.   \ifcsname DUtitle#1\endcsname%
    655. 

  655.     \csname DUtitle#1\endcsname{#2}%
    656. 

  656.   \else
    657. 

  657.     \smallskip\noindent{\bf #2}\smallskip%
    658. 

  658.   \fi
    659. 

  659. }"""
    660. 

    661. 

  661. PreambleCmds.topic = r"""
    662. 

  662. % topic (quote with heading)
    663. 

  663. \providecommand{\DUtopic}[2][class-arg]{%
    664. 

  664.   \ifcsname DUtopic#1\endcsname%
    665. 

  665.     \csname DUtopic#1\endcsname{#2}%
    666. 

  666.   \else
    667. 

  667.     \begin{quote}#2\end{quote}
    668. 

  668.   \fi
    669. 

  669. }"""
    670. 

    671. 

  671. PreambleCmds.transition = r"""
    672. 

  672. % transition (break, fancybreak, anonymous section)
    673. 

  673. \providecommand*{\DUtransition}[1][class-arg]{%
    674. 

  674.   \hspace*{\fill}\hrulefill\hspace*{\fill}
    675. 

  675.   \vskip 0.5\baselineskip
    676. 

  676. }"""
    677. 

    678. 

    679. 

  679. class DocumentClass(object):
    680. 

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

    682. 

  682.     def __init__(self, document_class, with_part=False):
    683. 

  683.         self.document_class = document_class
    684. 

  684.         self._with_part = with_part
    685. 

  685.         self.sections = ['section', 'subsection',
    686. 

  686.                          'subsubsection', 'subsubsubsection']
    687. 

  687.         self.sections_numbered = ['part', 'chapter', 'section', 'subsection',
    688. 

  688.                                   'subsubsection', 'subsubsubsection',
    689. 

  689.                                   'subsubsubsubsection']
    690. 

  690.         self.sections_unnumbered = ['title', 'subject', 'subsubject',
    691. 

  691.                                     'subsubsubject',
    692. 

  692.                                     'subsubsubsubject']
    693. 

  693.         if self.document_class in ('book', 'memoir', 'report',
    694. 

  694.                                    'scrbook', 'scrreprt'):
    695. 

  695.             self.sections_numbered.insert(0, 'chapter')
    696. 

  696.         if self._with_part:
    697. 

  697.             self.sections_numbered.insert(0, 'part')
    698. 

    699. 

  699.     def section(self, level):
    700. 

  700.         """Return the LaTeX section name for section `level`.
    701. 

    702. 

  702.         The name depends on the specific document class.
    703. 

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

  704.         """
    705. 

  705.         
    706. 

  706.         if level <= len(self.sections):
    707. 

  707.             return self.sections[level-1]
    708. 

  708.         else:
    709. 

  709.             return self.sections[-1]
    710. 

    711. 

    712. 

  712. class Table(object):
    713. 

  713.     """Manage a table while traversing.
    714. 

    715. 

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

  716.     class Table internal variables are in the Translator.
    717. 

    718. 

  718.     Table style might be
    719. 

    720. 

  720.     :standard:   horizontal and vertical lines
    721. 

  721.     :booktabs:   only horizontal lines (requires "booktabs" LaTeX package)
    722. 

  722.     :borderless: no borders around table cells
    723. 

  723.     :nolines:    alias for borderless
    724. 

  724.     """
    725. 

  725.     def __init__(self,translator,latex_type,table_style):
    726. 

  726.         self._translator = translator
    727. 

  727.         self._latex_type = latex_type
    728. 

  728.         self._table_style = table_style
    729. 

  729.         self._open = 0
    730. 

  730.         # miscellaneous attributes
    731. 

  731.         self._attrs = {}
    732. 

  732.         self._col_width = []
    733. 

  733.         self._rowspan = []
    734. 

  734.         self.stubs = []
    735. 

  735.         self._in_thead = 0
    736. 

    737. 

  737.     def open(self):
    738. 

  738.         self._open = True
    739. 

  739.         self._col_specs = []
    740. 

  740.         self.caption = []
    741. 

  741.         self._attrs = {}
    742. 

  742.         self._in_head = False # maybe context with search
    743. 

  743.     def close(self):
    744. 

  744.         self._open = False
    745. 

  745.         self._col_specs = None
    746. 

  746.         self.caption = []
    747. 

  747.         self._attrs = {}
    748. 

  748.         self.stubs = []
    749. 

  749.     def is_open(self):
    750. 

  750.         return self._open
    751. 

    752. 

  752.     def set_table_style(self, table_style):
    753. 

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

  754.             return
    755. 

  755.         self._table_style = table_style
    756. 

    757. 

  757.     def get_latex_type(self):
    758. 

  758.         if self._latex_type == 'longtable' and not self.caption:
    759. 

  759.             # do not advance the "table" counter (requires "ltcaption" package)
    760. 

  760.             return('longtable*')
    761. 

  761.         return self._latex_type
    762. 

    763. 

  763.     def set(self,attr,value):
    764. 

  764.         self._attrs[attr] = value
    765. 

  765.     def get(self,attr):
    766. 

  766.         if attr in self._attrs:
    767. 

  767.             return self._attrs[attr]
    768. 

  768.         return None
    769. 

    770. 

  770.     def get_vertical_bar(self):
    771. 

  771.         if self._table_style == 'standard':
    772. 

  772.             return '|'
    773. 

  773.         return ''
    774. 

    775. 

  775.     # horizontal lines are drawn below a row,
    776. 

  776.     def get_opening(self):
    777. 

  777.         return '\n'.join([r'\setlength{\DUtablewidth}{\linewidth}',
    778. 

  778.                           r'\begin{%s}[c]' % self.get_latex_type()])
    779. 

    780. 

  780.     def get_closing(self):
    781. 

  781.         closing = []
    782. 

  782.         if self._table_style == 'booktabs':
    783. 

  783.             closing.append(r'\bottomrule')
    784. 

  784.         # elif self._table_style == 'standard':
    785. 

  785.         #     closing.append(r'\hline')
    786. 

  786.         closing.append(r'\end{%s}' % self.get_latex_type())
    787. 

  787.         return '\n'.join(closing)
    788. 

    789. 

  789.     def visit_colspec(self, node):
    790. 

  790.         self._col_specs.append(node)
    791. 

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

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

    794. 

  794.     def get_colspecs(self):
    795. 

  795.         """Return column specification for longtable.
    796. 

    797. 

  797.         Assumes reST line length being 80 characters.
    798. 

  798.         Table width is hairy.
    799. 

    800. 

  800.         === ===
    801. 

  801.         ABC DEF
    802. 

  802.         === ===
    803. 

    804. 

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

  805.         """
    806. 

  806.         width = 80
    807. 

    808. 

  808.         total_width = 0.0
    809. 

  809.         # first see if we get too wide.
    810. 

  810.         for node in self._col_specs:
    811. 

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

  812.             total_width += colwidth
    813. 

  813.         self._col_width = []
    814. 

  814.         self._rowspan = []
    815. 

  815.         # donot make it full linewidth
    816. 

  816.         factor = 0.93
    817. 

  817.         if total_width > 1.0:
    818. 

  818.             factor /= total_width
    819. 

  819.         bar = self.get_vertical_bar()
    820. 

  820.         latex_table_spec = ''
    821. 

  821.         for node in self._col_specs:
    822. 

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

  823.             self._col_width.append(colwidth+0.005)
    824. 

  824.             self._rowspan.append(0)
    825. 

  825.             latex_table_spec += '%sp{%.3f\\DUtablewidth}' % (bar, colwidth+0.005)
    826. 

  826.         return latex_table_spec+bar
    827. 

    828. 

  828.     def get_column_width(self):
    829. 

  829.         """Return columnwidth for current cell (not multicell)."""
    830. 

  830.         return '%.2f\\DUtablewidth' % self._col_width[self._cell_in_row-1]
    831. 

    832. 

  832.     def get_multicolumn_width(self, start, len_):
    833. 

  833.         """Return sum of columnwidths for multicell."""
    834. 

  834.         mc_width = sum([width
    835. 

  835.                        for width in ([self._col_width[start + co - 1]
    836. 

  836.                                      for co in range (len_)])])
    837. 

  837.         return '%.2f\\DUtablewidth' % mc_width
    838. 

    839. 

  839.     def get_caption(self):
    840. 

  840.         if not self.caption:
    841. 

  841.             return ''
    842. 

  842.         caption = ''.join(self.caption)
    843. 

  843.         if 1 == self._translator.thead_depth():
    844. 

  844.             return r'\caption{%s}\\' '\n' % caption
    845. 

  845.         return r'\caption[]{%s (... continued)}\\' '\n' % caption
    846. 

    847. 

  847.     def need_recurse(self):
    848. 

  848.         if self._latex_type == 'longtable':
    849. 

  849.             return 1 == self._translator.thead_depth()
    850. 

  850.         return 0
    851. 

    852. 

  852.     def visit_thead(self):
    853. 

  853.         self._in_thead += 1
    854. 

  854.         if self._table_style == 'standard':
    855. 

  855.             return ['\\hline\n']
    856. 

  856.         elif self._table_style == 'booktabs':
    857. 

  857.             return ['\\toprule\n']
    858. 

  858.         return []
    859. 

  859.     def depart_thead(self):
    860. 

  860.         a = []
    861. 

  861.         #if self._table_style == 'standard':
    862. 

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

  863.         if self._table_style == 'booktabs':
    864. 

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

  865.         if self._latex_type == 'longtable':
    866. 

  866.             if 1 == self._translator.thead_depth():
    867. 

  867.                 a.append('\\endfirsthead\n')
    868. 

  868.             else:
    869. 

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

  870.                 a.append(r'\multicolumn{%d}{c}' % len(self._col_specs) +
    871. 

  871.                          r'{\hfill ... continued on next page} \\')
    872. 

  872.                 a.append('\n\\endfoot\n\\endlastfoot\n')
    873. 

  873.         # for longtable one could add firsthead, foot and lastfoot
    874. 

  874.         self._in_thead -= 1
    875. 

  875.         return a
    876. 

  876.     def visit_row(self):
    877. 

  877.         self._cell_in_row = 0
    878. 

  878.     def depart_row(self):
    879. 

  879.         res = [' \\\\\n']
    880. 

  880.         self._cell_in_row = None  # remove cell counter
    881. 

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

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

  883.                 self._rowspan[i] -= 1
    884. 

    885. 

  885.         if self._table_style == 'standard':
    886. 

  886.             rowspans = [i+1 for i in range(len(self._rowspan))
    887. 

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

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

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

  890.             else:
    891. 

  891.                 cline = ''
    892. 

  892.                 rowspans.reverse()
    893. 

  893.                 # TODO merge clines
    894. 

  894.                 while 1:
    895. 

  895.                     try:
    896. 

  896.                         c_start = rowspans.pop()
    897. 

  897.                     except:
    898. 

  898.                         break
    899. 

  899.                     cline += '\\cline{%d-%d}\n' % (c_start,c_start)
    900. 

  900.                 res.append(cline)
    901. 

  901.         return res
    902. 

    903. 

  903.     def set_rowspan(self,cell,value):
    904. 

  904.         try:
    905. 

  905.             self._rowspan[cell] = value
    906. 

  906.         except:
    907. 

  907.             pass
    908. 

  908.     def get_rowspan(self,cell):
    909. 

  909.         try:
    910. 

  910.             return self._rowspan[cell]
    911. 

  911.         except:
    912. 

  912.             return 0
    913. 

  913.     def get_entry_number(self):
    914. 

  914.         return self._cell_in_row
    915. 

  915.     def visit_entry(self):
    916. 

  916.         self._cell_in_row += 1
    917. 

  917.     def is_stub_column(self):
    918. 

  918.         if len(self.stubs) >= self._cell_in_row:
    919. 

  919.             return self.stubs[self._cell_in_row-1]
    920. 

  920.         return False
    921. 

    922. 

    923. 

  923. class LaTeXTranslator(nodes.NodeVisitor):
    924. 

    925. 

  925.     # When options are given to the documentclass, latex will pass them
    926. 

  926.     # to other packages, as done with babel.
    927. 

  927.     # Dummy settings might be taken from document settings
    928. 

    929. 

  929.     # Config setting defaults
    930. 

  930.     # -----------------------
    931. 

    932. 

  932.     # TODO: use mixins for different implementations.
    933. 

  933.     # list environment for docinfo. else tabularx
    934. 

  934.     ## use_optionlist_for_docinfo = False # TODO: NOT YET IN USE
    935. 

    936. 

  936.     # Use compound enumerations (1.A.1.)
    937. 

  937.     compound_enumerators = 0
    938. 

    939. 

  939.     # If using compound enumerations, include section information.
    940. 

  940.     section_prefix_for_enumerators = 0
    941. 

    942. 

  942.     # This is the character that separates the section ("." subsection ...)
    943. 

  943.     # prefix from the regular list enumerator.
    944. 

  944.     section_enumerator_separator = '-'
    945. 

    946. 

  946.     # Auxiliary variables
    947. 

  947.     # -------------------
    948. 

    949. 

  949.     has_latex_toc = False # is there a toc in the doc? (needed by minitoc)
    950. 

  950.     is_toc_list = False   # is the current bullet_list a ToC?
    951. 

  951.     section_level = 0
    952. 

    953. 

  953.     # Flags to encode():
    954. 

  954.     # inside citation reference labels underscores dont need to be escaped
    955. 

  955.     inside_citation_reference_label = False
    956. 

  956.     verbatim = False                   # do not encode
    957. 

  957.     insert_non_breaking_blanks = False # replace blanks by "~"
    958. 

  958.     insert_newline = False             # add latex newline commands
    959. 

  959.     literal = False                    # literal text (block or inline)
    960. 

    961. 

    962. 

  962.     def __init__(self, document, babel_class=Babel):
    963. 

  963.         nodes.NodeVisitor.__init__(self, document)
    964. 

  964.         # Reporter
    965. 

  965.         # ~~~~~~~~
    966. 

  966.         self.warn = self.document.reporter.warning
    967. 

  967.         self.error = self.document.reporter.error
    968. 

    969. 

  969.         # Settings
    970. 

  970.         # ~~~~~~~~
    971. 

  971.         self.settings = settings = document.settings
    972. 

  972.         self.latex_encoding = self.to_latex_encoding(settings.output_encoding)
    973. 

  973.         self.use_latex_toc = settings.use_latex_toc
    974. 

  974.         self.use_latex_docinfo = settings.use_latex_docinfo
    975. 

  975.         self._use_latex_citations = settings.use_latex_citations
    976. 

  976.         self.embed_stylesheet = settings.embed_stylesheet
    977. 

  977.         self._reference_label = settings.reference_label
    978. 

  978.         self.hyperlink_color = settings.hyperlink_color
    979. 

  979.         self.compound_enumerators = settings.compound_enumerators
    980. 

  980.         # self.font_encoding = getattr(settings, 'font_encoding', '')
    981. 

  981.         self.font_encoding = None
    982. 

  982.         self.section_prefix_for_enumerators = (
    983. 

  983.             settings.section_prefix_for_enumerators)
    984. 

  984.         self.section_enumerator_separator = (
    985. 

  985.             settings.section_enumerator_separator.replace('_', r'\_'))
    986. 

  986.         # literal blocks:
    987. 

  987.         self.literal_block_env = ''
    988. 

  988.         self.literal_block_options = ''
    989. 

  989.         if settings.literal_block_env != '':
    990. 

  990.             (none,
    991. 

  991.              self.literal_block_env,
    992. 

  992.              self.literal_block_options,
    993. 

  993.              none ) = re.split('(\w+)(.*)', settings.literal_block_env)
    994. 

  994.         elif settings.use_verbatim_when_possible:
    995. 

  995.             self.literal_block_env = 'verbatim'
    996. 

  996.         #
    997. 

  997.         if self.settings.use_bibtex:
    998. 

  998.             self.bibtex = self.settings.use_bibtex.split(',',1)
    999. 

  999.             # TODO avoid errors on not declared citations.
    1000. 

  1000.         else:
    1001. 

  1001.             self.bibtex = None
    1002. 

  1002.         # language module for Docutils-generated text
    1003. 

  1003.         # (labels, bibliographic_fields, and author_separators)
    1004. 

  1004.         self.language_module = languages.get_language(settings.language_code,
    1005. 

  1005.                                               document.reporter)
    1006. 

  1006.         self.babel = babel_class(settings.language_code, document.reporter)
    1007. 

  1007.         self.author_separator = self.language_module.author_separators[0]
    1008. 

  1008.         d_options = [self.settings.documentoptions]
    1009. 

  1009.         if self.babel.language not in ('english', ''):
    1010. 

  1010.             d_options.append(self.babel.language)
    1011. 

  1011.         self.documentoptions = ','.join(filter(None, d_options))
    1012. 

  1012.         self.d_class = DocumentClass(settings.documentclass,
    1013. 

  1013.                                      settings.use_part_section)
    1014. 

  1014.         # graphic package options:
    1015. 

  1015.         if self.settings.graphicx_option == '':
    1016. 

  1016.             self.graphicx_package = r'\usepackage{graphicx}'
    1017. 

  1017.         elif self.settings.graphicx_option.lower() == 'auto':
    1018. 

  1018.             self.graphicx_package = PreambleCmds.graphicx_auto
    1019. 

  1019.         else:
    1020. 

  1020.             self.graphicx_package = (r'\usepackage[%s]{graphicx}' %
    1021. 

  1021.                                      self.settings.graphicx_option)
    1022. 

  1022.         # footnotes:
    1023. 

  1023.         self.docutils_footnotes = settings.docutils_footnotes
    1024. 

  1024.         if settings.use_latex_footnotes:
    1025. 

  1025.             self.docutils_footnotes = True
    1026. 

  1026.             self.warn('`use_latex_footnotes` is deprecated. '
    1027. 

  1027.                       'The setting has been renamed to `docutils_footnotes` '
    1028. 

  1028.                       'and the alias will be removed in a future version.')
    1029. 

  1029.         self.figure_footnotes = settings.figure_footnotes
    1030. 

  1030.         if self.figure_footnotes:
    1031. 

  1031.             self.docutils_footnotes = True
    1032. 

  1032.             self.warn('The "figure footnotes" workaround/setting is strongly '
    1033. 

  1033.                       'deprecated and will be removed in a future version.')
    1034. 

    1035. 

  1035.         # Output collection stacks
    1036. 

  1036.         # ~~~~~~~~~~~~~~~~~~~~~~~~
    1037. 

    1038. 

  1038.         # Document parts
    1039. 

  1039.         #self.head_prefix = [r'\documentclass[%s]{%s}' %
    1040. 

  1040.         #    (self.documentoptions, self.settings.documentclass)]
    1041. 

  1041.         self.head_prefix = []
    1042. 

  1042.         self.requirements = SortableDict() # made a list in depart_document()
    1043. 

  1043.         # self.requirements['__static'] = r'\usepackage{ifthen}'
    1044. 

  1044.         self.latex_preamble = []
    1045. 

  1045.         self.context_preamble = [settings.context_preamble]
    1046. 

  1046.         self.stylesheet = []
    1047. 

  1047.         self.fallbacks = SortableDict() # made a list in depart_document()
    1048. 

  1048.         self.pdfsetup = [] # PDF properties (hyperref package)
    1049. 

  1049.         self.title = []
    1050. 

  1050.         self.subtitle = []
    1051. 

  1051.         self.titledata = [] # \title, \author, \date
    1052. 

  1052.         ## self.body_prefix = ['\\begin{document}\n']
    1053. 

  1053.         self.body_pre_docinfo = [] # \maketitle
    1054. 

  1054.         self.docinfo = []
    1055. 

  1055.         self.dedication = []
    1056. 

  1056.         self.abstract = []
    1057. 

  1057.         self.body = []
    1058. 

  1058.         ## self.body_suffix = ['\\end{document}\n']
    1059. 

    1060. 

  1060.         # A heterogenous stack used in conjunction with the tree traversal.
    1061. 

  1061.         # Make sure that the pops correspond to the pushes:
    1062. 

  1062.         self.context = []
    1063. 

    1064. 

  1064.         # Title metadata:
    1065. 

  1065.         self.title_labels = []
    1066. 

  1066.         self.subtitle_labels = []
    1067. 

  1067.         # (if use_latex_docinfo: collects lists of
    1068. 

  1068.         # author/organization/contact/address lines)
    1069. 

  1069.         self.author_stack = []
    1070. 

  1070.         self.date = []
    1071. 

    1072. 

  1072.         # PDF properties: pdftitle, pdfauthor
    1073. 

  1073.         # TODO?: pdfcreator, pdfproducer, pdfsubject, pdfkeywords
    1074. 

  1074.         self.pdfinfo = []
    1075. 

  1075.         self.pdfauthor = []
    1076. 

    1077. 

  1077.         # Stack of section counters so that we don't have to use_latex_toc.
    1078. 

  1078.         # This will grow and shrink as processing occurs.
    1079. 

  1079.         # Initialized for potential first-level sections.
    1080. 

  1080.         self._section_number = [0]
    1081. 

    1082. 

  1082.         # The current stack of enumerations so that we can expand
    1083. 

  1083.         # them into a compound enumeration.
    1084. 

  1084.         self._enumeration_counters = []
    1085. 

  1085.         # The maximum number of enumeration counters we've used.
    1086. 

  1086.         # If we go beyond this number, we need to create a new
    1087. 

  1087.         # counter; otherwise, just reuse an old one.
    1088. 

  1088.         self._max_enumeration_counters = 0
    1089. 

    1090. 

  1090.         self._bibitems = []
    1091. 

    1092. 

  1092.         # object for a table while proccessing.
    1093. 

  1093.         self.table_stack = []
    1094. 

  1094.         self.active_table = Table(self, 'longtable', settings.table_style)
    1095. 

    1096. 

  1096.         # Where to collect the output of visitor methods (default: body)
    1097. 

  1097.         self.out = self.body
    1098. 

  1098.         self.out_stack = []  # stack of output collectors
    1099. 

    1100. 

  1100.         # Process settings
    1101. 

  1101.         # ~~~~~~~~~~~~~~~~
    1102. 

  1102.         # Encodings:
    1103. 

  1103.         # Docutils' output-encoding => TeX input encoding
    1104. 

  1104.         #if self.latex_encoding != 'ascii':
    1105. 

  1105.         #    self.requirements['_inputenc'] = (r'\usepackage[%s]{inputenc}'
    1106. 

  1106.         #                                      % self.latex_encoding)
    1107. 

  1107.         # TeX font encoding
    1108. 

  1108.         #if self.font_encoding:
    1109. 

  1109.         #    self.requirements['_fontenc'] = (r'\usepackage[%s]{fontenc}' %
    1110. 

  1110.         #                                     self.font_encoding)
    1111. 

  1111.         # page layout with typearea (if there are relevant document options)
    1112. 

  1112.         if (settings.documentclass.find('scr') == -1 and
    1113. 

  1113.             (self.documentoptions.find('DIV') != -1 or
    1114. 

  1114.              self.documentoptions.find('BCOR') != -1)):
    1115. 

  1115.             self.requirements['typearea'] = r'\usepackage{typearea}'
    1116. 

    1117. 

  1117.         # Stylesheets
    1118. 

  1118.         # get list of style sheets from settings
    1119. 

  1119.         styles = utils.get_stylesheet_list(settings)
    1120. 

  1120.         # adapt path if --stylesheet_path is used
    1121. 

  1121.         if settings.stylesheet_path and not(self.embed_stylesheet):
    1122. 

  1122.             styles = [utils.relative_path(settings._destination, sheet)
    1123. 

  1123.                       for sheet in styles]
    1124. 

  1124.         for sheet in styles:
    1125. 

  1125.             (base, ext) = os.path.splitext(sheet)
    1126. 

  1126.             is_package = ext in ['.sty', '']
    1127. 

  1127.             if self.embed_stylesheet:
    1128. 

  1128.                 if is_package:
    1129. 

  1129.                     sheet = base + '.sty' # adapt package name
    1130. 

  1130.                     # wrap in \makeatletter, \makeatother
    1131. 

  1131.                     wrapper = PreambleCmds.embedded_package_wrapper
    1132. 

  1132.                 else:
    1133. 

  1133.                     wrapper = '%% embedded stylesheet: %s\n%s'
    1134. 

  1134.                 settings.record_dependencies.add(sheet)
    1135. 

  1135.                 self.stylesheet.append(wrapper %
    1136. 

  1136.                     (sheet, io.FileInput(source_path=sheet, encoding='utf-8').read()))
    1137. 

  1137.             else: # link to style sheet
    1138. 

  1138.                 if is_package:
    1139. 

  1139.                     self.stylesheet.append(r'\usepackage{%s}' % base)
    1140. 

  1140.                 else:
    1141. 

  1141.                     self.stylesheet.append(r'\input{%s}' % sheet)
    1142. 

    1143. 

  1143.         # PDF setup
    1144. 

  1144.         if self.hyperlink_color in ('0', 'false', 'False', ''):
    1145. 

  1145.             self.hyperref_options = ''
    1146. 

  1146.         else:
    1147. 

  1147.             self.hyperref_options = 'colorlinks=true,linkcolor=%s,urlcolor=%s' % (
    1148. 

  1148.                                       self.hyperlink_color, self.hyperlink_color)
    1149. 

  1149.         if settings.hyperref_options:
    1150. 

  1150.             self.hyperref_options += ',' + settings.hyperref_options
    1151. 

    1152. 

  1152.         # LaTeX Toc
    1153. 

  1153.         # include all supported sections in toc and PDF bookmarks
    1154. 

  1154.         # (or use documentclass-default (as currently))?
    1155. 

  1155.         ## if self.use_latex_toc:
    1156. 

  1156.         ##    self.requirements['tocdepth'] = (r'\setcounter{tocdepth}{%d}' %
    1157. 

  1157.         ##                                     len(self.d_class.sections))
    1158. 

    1159. 

  1159.         # LaTeX section numbering
    1160. 

  1160.         if not self.settings.sectnum_xform: # section numbering by LaTeX:
    1161. 

  1161.             # sectnum_depth:
    1162. 

  1162.             #   None  "sectnum" directive without depth arg -> LaTeX default
    1163. 

  1163.             #   0     no "sectnum" directive -> no section numbers
    1164. 

  1164.             #   else  value of the "depth" argument: translate to LaTeX level
    1165. 

  1165.             #         -1  part    (0 with "article" document class)
    1166. 

  1166.             #          0  chapter (missing in "article" document class)
    1167. 

  1167.             #          1  section
    1168. 

  1168.             #          2  subsection
    1169. 

  1169.             #          3  subsubsection
    1170. 

  1170.             #          4  paragraph
    1171. 

  1171.             #          5  subparagraph
    1172. 

  1172.             if settings.sectnum_depth is not None:
    1173. 

  1173.                 # limit to supported levels
    1174. 

  1174.                 sectnum_depth = min(settings.sectnum_depth,
    1175. 

  1175.                                     len(self.d_class.sections))
    1176. 

  1176.                 # adjust to document class and use_part_section settings
    1177. 

  1177.                 if 'chapter' in  self.d_class.sections:
    1178. 

  1178.                     sectnum_depth -= 1
    1179. 

  1179.                 if self.d_class.sections[0] == 'part':
    1180. 

  1180.                     sectnum_depth -= 1
    1181. 

  1181.                 self.requirements['sectnum_depth'] = (
    1182. 

  1182.                     r'\setcounter{secnumdepth}{%d}' % sectnum_depth)
    1183. 

  1183.             # start with specified number:
    1184. 

  1184.             if (hasattr(settings, 'sectnum_start') and
    1185. 

  1185.                 settings.sectnum_start != 1):
    1186. 

  1186.                 self.requirements['sectnum_start'] = (
    1187. 

  1187.                     r'\setcounter{%s}{%d}' % (self.d_class.sections[0],
    1188. 

  1188.                                               settings.sectnum_start-1))
    1189. 

  1189.             # currently ignored (configure in a stylesheet):
    1190. 

  1190.             ## settings.sectnum_prefix
    1191. 

  1191.             ## settings.sectnum_suffix
    1192. 

    1193. 

    1194. 

  1194.     # Auxiliary Methods
    1195. 

  1195.     # -----------------
    1196. 

    1197. 

  1197.     def to_latex_encoding(self,docutils_encoding):
    1198. 

  1198.         """Translate docutils encoding name into LaTeX's.
    1199. 

    1200. 

  1200.         Default method is remove "-" and "_" chars from docutils_encoding.
    1201. 

  1201.         """
    1202. 

  1202.         tr = {  'iso-8859-1': 'latin1',     # west european
    1203. 

  1203.                 'iso-8859-2': 'latin2',     # east european
    1204. 

  1204.                 'iso-8859-3': 'latin3',     # esperanto, maltese
    1205. 

  1205.                 'iso-8859-4': 'latin4',     # north european, scandinavian, baltic
    1206. 

  1206.                 'iso-8859-5': 'iso88595',   # cyrillic (ISO)
    1207. 

  1207.                 'iso-8859-9': 'latin5',     # turkish
    1208. 

  1208.                 'iso-8859-15': 'latin9',    # latin9, update to latin1.
    1209. 

  1209.                 'mac_cyrillic': 'maccyr',   # cyrillic (on Mac)
    1210. 

  1210.                 'windows-1251': 'cp1251',   # cyrillic (on Windows)
    1211. 

  1211.                 'koi8-r': 'koi8-r',         # cyrillic (Russian)
    1212. 

  1212.                 'koi8-u': 'koi8-u',         # cyrillic (Ukrainian)
    1213. 

  1213.                 'windows-1250': 'cp1250',   #
    1214. 

  1214.                 'windows-1252': 'cp1252',   #
    1215. 

  1215.                 'us-ascii': 'ascii',        # ASCII (US)
    1216. 

  1216.                 # unmatched encodings
    1217. 

  1217.                 #'': 'applemac',
    1218. 

  1218.                 #'': 'ansinew',  # windows 3.1 ansi
    1219. 

  1219.                 #'': 'ascii',    # ASCII encoding for the range 32--127.
    1220. 

  1220.                 #'': 'cp437',    # dos latin us
    1221. 

  1221.                 #'': 'cp850',    # dos latin 1
    1222. 

  1222.                 #'': 'cp852',    # dos latin 2
    1223. 

  1223.                 #'': 'decmulti',
    1224. 

  1224.                 #'': 'latin10',
    1225. 

  1225.                 #'iso-8859-6': ''   # arabic
    1226. 

  1226.                 #'iso-8859-7': ''   # greek
    1227. 

  1227.                 #'iso-8859-8': ''   # hebrew
    1228. 

  1228.                 #'iso-8859-10': ''   # latin6, more complete iso-8859-4
    1229. 

  1229.              }
    1230. 

  1230.         encoding = docutils_encoding.lower()
    1231. 

  1231.         if encoding in tr:
    1232. 

  1232.             return tr[encoding]
    1233. 

  1233.         # convert: latin-1, latin_1, utf-8 and similar things
    1234. 

  1234.         encoding = encoding.replace('_', '').replace('-', '')
    1235. 

  1235.         # strip the error handler
    1236. 

  1236.         return encoding.split(':')[0]
    1237. 

    1238. 

  1238.     def language_label(self, docutil_label):
    1239. 

  1239.         return self.language_module.labels[docutil_label]
    1240. 

    1241. 

  1241.     def ensure_math(self, text):
    1242. 

  1242.         if not hasattr(self, 'ensure_math_re'):
    1243. 

  1243.             chars = { # lnot,pm,twosuperior,threesuperior,mu,onesuperior,times,div
    1244. 

  1244.                      'latin1' : '\xac\xb1\xb2\xb3\xb5\xb9\xd7\xf7' , # ¬±²³µ¹×÷
    1245. 

  1245.                      # TODO?: use texcomp instead.
    1246. 

  1246.                     }
    1247. 

  1247.             self.ensure_math_re = re.compile('([%s])' % chars['latin1'])
    1248. 

  1248.         text = self.ensure_math_re.sub(r'\\ensuremath{\1}', text)
    1249. 

  1249.         return text
    1250. 

    1251. 

  1251.     def encode(self, text):
    1252. 

  1252.         """Return text with 'problematic' characters escaped.
    1253. 

    1254. 

  1254.         Escape the ten special printing characters ``# $ % & ~ _ ^ \ { }``,
    1255. 

  1255.         square brackets ``[ ]``, double quotes and (in OT1) ``< | >``.
    1256. 

    1257. 

  1257.         Separate ``-`` (and more in literal text) to prevent input ligatures.
    1258. 

    1259. 

  1259.         Translate non-supported Unicode characters.
    1260. 

  1260.         """
    1261. 

  1261.         if self.verbatim:
    1262. 

  1262.             return text
    1263. 

  1263.         # Separate compound characters, e.g. '--' to '-{}-'.
    1264. 

  1264.         separate_chars = '-'
    1265. 

  1265.         # In monospace-font, we also separate ',,', '``' and "''" and some
    1266. 

  1266.         # other characters which can't occur in non-literal text.
    1267. 

  1267.         if self.literal:
    1268. 

  1268.             separate_chars += ',`\'"<>'
    1269. 

  1269.         # LaTeX encoding maps:
    1270. 

  1270.         special_chars = {
    1271. 

  1271.             ord('#'): ur'\#',
    1272. 

  1272.             ord('$'): ur'\$',
    1273. 

  1273.             ord('%'): ur'\%',
    1274. 

  1274.             ord('&'): ur'\&',
    1275. 

  1275.             ord('~'): ur'\textasciitilde{}',
    1276. 

  1276.             ord('_'): ur'\_',
    1277. 

  1277.             ord('^'): ur'\textasciicircum{}',
    1278. 

  1278.             ord('\\'): ur'\textbackslash{}',
    1279. 

  1279.             ord('{'): ur'\{',
    1280. 

  1280.             ord('}'): ur'\}',
    1281. 

  1281.         # Square brackets are ordinary chars and cannot be escaped with '\',
    1282. 

  1282.         # so we put them in a group '{[}'. (Alternative: ensure that all
    1283. 

  1283.         # macros with optional arguments are terminated with {} and text
    1284. 

  1284.         # inside any optional argument is put in a group ``[{text}]``).
    1285. 

  1285.         # Commands with optional args inside an optional arg must be put
    1286. 

  1286.         # in a group, e.g. ``\item[{\hyperref[label]{text}}]``.
    1287. 

  1287.             ord('['): ur'{[}',
    1288. 

  1288.             ord(']'): ur'{]}'
    1289. 

  1289.         }
    1290. 

  1290.         # Unicode chars that are not recognized by LaTeX's utf8 encoding
    1291. 

  1291.         unsupported_unicode_chars = {
    1292. 

  1292.             0x00A0: ur'~', # NO-BREAK SPACE
    1293. 

  1293.             0x00AD: ur'\-', # SOFT HYPHEN
    1294. 

  1294.             #
    1295. 

  1295.             0x2008: ur'\,', # PUNCTUATION SPACE???
    1296. 

  1296.             0x2011: ur'\hbox{-}', # NON-BREAKING HYPHEN
    1297. 

  1297.             0x202F: ur'\,', # NARROW NO-BREAK SPACE
    1298. 

  1298.             0x21d4: ur'$\Leftrightarrow$',
    1299. 

  1299.             # Docutils footnote symbols:
    1300. 

  1300.             0x2660: ur'$\spadesuit$',
    1301. 

  1301.             0x2663: ur'$\clubsuit$',
    1302. 

  1302.         }
    1303. 

  1303.         # Unicode chars that are recognized by LaTeX's utf8 encoding
    1304. 

  1304.         unicode_chars = {
    1305. 

  1305.             0x200C: ur'\textcompwordmark', # ZERO WIDTH NON-JOINER
    1306. 

  1306.             0x2013: ur'\textendash{}',
    1307. 

  1307.             0x2014: ur'\textemdash{}',
    1308. 

  1308.             0x2018: ur'\textquoteleft{}',
    1309. 

  1309.             0x2019: ur'\textquoteright{}',
    1310. 

  1310.             0x201A: ur'\quotesinglbase{}', # SINGLE LOW-9 QUOTATION MARK
    1311. 

  1311.             0x201C: ur'\textquotedblleft{}',
    1312. 

  1312.             0x201D: ur'\textquotedblright{}',
    1313. 

  1313.             0x201E: ur'\quotedblbase{}', # DOUBLE LOW-9 QUOTATION MARK
    1314. 

  1314.             0x2030: ur'\textperthousand{}',   # PER MILLE SIGN
    1315. 

  1315.             0x2031: ur'\textpertenthousand{}', # PER TEN THOUSAND SIGN
    1316. 

  1316.             0x2039: ur'\guilsinglleft{}',
    1317. 

  1317.             0x203A: ur'\guilsinglright{}',
    1318. 

  1318.             0x2423: ur'\textvisiblespace{}',  # OPEN BOX
    1319. 

  1319.             0x2020: ur'\dag{}',
    1320. 

  1320.             0x2021: ur'\ddag{}',
    1321. 

  1321.             0x2026: ur'\dots{}',
    1322. 

  1322.             0x2122: ur'\texttrademark{}',
    1323. 

  1323.         }
    1324. 

  1324.         # Unicode chars that require a feature/package to render
    1325. 

  1325.         pifont_chars = {
    1326. 

  1326.             0x2665: ur'\ding{170}',     # black heartsuit
    1327. 

  1327.             0x2666: ur'\ding{169}',     # black diamondsuit
    1328. 

  1328.             0x2713: ur'\ding{51}',      # check mark
    1329. 

  1329.             0x2717: ur'\ding{55}',      # check mark
    1330. 

  1330.         }
    1331. 

  1331.         # recognized with 'utf8', if textcomp is loaded
    1332. 

  1332.         textcomp_chars = {
    1333. 

  1333.             # Latin-1 Supplement
    1334. 

  1334.             0x00a2: ur'\textcent{}',          # ¢ CENT SIGN
    1335. 

  1335.             0x00a4: ur'\textcurrency{}',      # ¤ CURRENCY SYMBOL
    1336. 

  1336.             0x00a5: ur'\textyen{}',           # ¥ YEN SIGN
    1337. 

  1337.             0x00a6: ur'\textbrokenbar{}',     # ¦ BROKEN BAR
    1338. 

  1338.             0x00a7: ur'\textsection{}',       # § SECTION SIGN
    1339. 

  1339.             0x00a8: ur'\textasciidieresis{}', # ¨ DIAERESIS
    1340. 

  1340.             0x00a9: ur'\textcopyright{}',     # © COPYRIGHT SIGN
    1341. 

  1341.             0x00aa: ur'\textordfeminine{}',   # ª FEMININE ORDINAL INDICATOR
    1342. 

  1342.             0x00ac: ur'\textlnot{}',          # ¬ NOT SIGN
    1343. 

  1343.             0x00ae: ur'\textregistered{}',    # ® REGISTERED SIGN
    1344. 

  1344.             0x00af: ur'\textasciimacron{}',   # ¯ MACRON
    1345. 

  1345.             0x00b0: ur'\textdegree{}',        # ° DEGREE SIGN
    1346. 

  1346.             0x00b1: ur'\textpm{}',            # ± PLUS-MINUS SIGN
    1347. 

  1347.             0x00b2: ur'\texttwosuperior{}',   # ² SUPERSCRIPT TWO
    1348. 

  1348.             0x00b3: ur'\textthreesuperior{}', # ³ SUPERSCRIPT THREE
    1349. 

  1349.             0x00b4: ur'\textasciiacute{}',    # ´ ACUTE ACCENT
    1350. 

  1350.             0x00b5: ur'\textmu{}',            # µ MICRO SIGN
    1351. 

  1351.             0x00b6: ur'\textparagraph{}',     #  PILCROW SIGN # not equal to \textpilcrow
    1352. 

  1352.             0x00b9: ur'\textonesuperior{}',   # ¹ SUPERSCRIPT ONE
    1353. 

  1353.             0x00ba: ur'\textordmasculine{}',  # º MASCULINE ORDINAL INDICATOR
    1354. 

  1354.             0x00bc: ur'\textonequarter{}',    # 1/4 FRACTION
    1355. 

  1355.             0x00bd: ur'\textonehalf{}',       # 1/2 FRACTION
    1356. 

  1356.             0x00be: ur'\textthreequarters{}', # 3/4 FRACTION
    1357. 

  1357.             0x00d7: ur'\texttimes{}',         # × MULTIPLICATION SIGN
    1358. 

  1358.             0x00f7: ur'\textdiv{}',           # ÷ DIVISION SIGN
    1359. 

  1359.             #
    1360. 

  1360.             0x0192: ur'\textflorin{}',        # LATIN SMALL LETTER F WITH HOOK
    1361. 

  1361.             0x02b9: ur'\textasciiacute{}',    # MODIFIER LETTER PRIME
    1362. 

  1362.             0x02ba: ur'\textacutedbl{}',      # MODIFIER LETTER DOUBLE PRIME
    1363. 

  1363.             0x2016: ur'\textbardbl{}',        # DOUBLE VERTICAL LINE
    1364. 

  1364.             0x2022: ur'\textbullet{}',        # BULLET
    1365. 

  1365.             0x2032: ur'\textasciiacute{}',    # PRIME
    1366. 

  1366.             0x2033: ur'\textacutedbl{}',      # DOUBLE PRIME
    1367. 

  1367.             0x2035: ur'\textasciigrave{}',    # REVERSED PRIME
    1368. 

  1368.             0x2036: ur'\textgravedbl{}',      # REVERSED DOUBLE PRIME
    1369. 

  1369.             0x203b: ur'\textreferencemark{}', # REFERENCE MARK
    1370. 

  1370.             0x203d: ur'\textinterrobang{}',   # INTERROBANG
    1371. 

  1371.             0x2044: ur'\textfractionsolidus{}', # FRACTION SLASH
    1372. 

  1372.             0x2045: ur'\textlquill{}',        # LEFT SQUARE BRACKET WITH QUILL
    1373. 

  1373.             0x2046: ur'\textrquill{}',        # RIGHT SQUARE BRACKET WITH QUILL
    1374. 

  1374.             0x2052: ur'\textdiscount{}',      # COMMERCIAL MINUS SIGN
    1375. 

  1375.             0x20a1: ur'\textcolonmonetary{}', # COLON SIGN
    1376. 

  1376.             0x20a3: ur'\textfrenchfranc{}',   # FRENCH FRANC SIGN
    1377. 

  1377.             0x20a4: ur'\textlira{}',          # LIRA SIGN
    1378. 

  1378.             0x20a6: ur'\textnaira{}',         # NAIRA SIGN
    1379. 

  1379.             0x20a9: ur'\textwon{}',           # WON SIGN
    1380. 

  1380.             0x20ab: ur'\textdong{}',          # DONG SIGN
    1381. 

  1381.             0x20ac: ur'\texteuro{}',          # EURO SIGN
    1382. 

  1382.             0x20b1: ur'\textpeso{}',          # PESO SIGN
    1383. 

  1383.             0x20b2: ur'\textguarani{}',       # GUARANI SIGN
    1384. 

  1384.             0x2103: ur'\textcelsius{}',       # DEGREE CELSIUS
    1385. 

  1385.             0x2116: ur'\textnumero{}',        # NUMERO SIGN
    1386. 

  1386.             0x2117: ur'\textcircledP{}',      # SOUND RECORDING COYRIGHT
    1387. 

  1387.             0x211e: ur'\textrecipe{}',        # PRESCRIPTION TAKE
    1388. 

  1388.             0x2120: ur'\textservicemark{}',   # SERVICE MARK
    1389. 

  1389.             0x2122: ur'\texttrademark{}',     # TRADE MARK SIGN
    1390. 

  1390.             0x2126: ur'\textohm{}',           # OHM SIGN
    1391. 

  1391.             0x2127: ur'\textmho{}',           # INVERTED OHM SIGN
    1392. 

  1392.             0x212e: ur'\textestimated{}',     # ESTIMATED SYMBOL
    1393. 

  1393.             0x2190: ur'\textleftarrow{}',     # LEFTWARDS ARROW
    1394. 

  1394.             0x2191: ur'\textuparrow{}',       # UPWARDS ARROW
    1395. 

  1395.             0x2192: ur'\textrightarrow{}',    # RIGHTWARDS ARROW
    1396. 

  1396.             0x2193: ur'\textdownarrow{}',     # DOWNWARDS ARROW
    1397. 

  1397.             0x2212: ur'\textminus{}',         # MINUS SIGN
    1398. 

  1398.             0x2217: ur'\textasteriskcentered{}', # ASTERISK OPERATOR
    1399. 

  1399.             0x221a: ur'\textsurd{}',          # SQUARE ROOT
    1400. 

  1400.             0x2422: ur'\textblank{}',         # BLANK SYMBOL
    1401. 

  1401.             0x25e6: ur'\textopenbullet{}',    # WHITE BULLET
    1402. 

  1402.             0x25ef: ur'\textbigcircle{}',     # LARGE CIRCLE
    1403. 

  1403.             0x266a: ur'\textmusicalnote{}',   # EIGHTH NOTE
    1404. 

  1404.             0x26ad: ur'\textmarried{}',       # MARRIAGE SYMBOL
    1405. 

  1405.             0x26ae: ur'\textdivorced{}',      # DIVORCE SYMBOL
    1406. 

  1406.             0x27e8: ur'\textlangle{}',        # MATHEMATICAL LEFT ANGLE BRACKET
    1407. 

  1407.             0x27e9: ur'\textrangle{}',        # MATHEMATICAL RIGHT ANGLE BRACKET
    1408. 

  1408.         }
    1409. 

  1409.         # TODO: greek alphabet ... ?
    1410. 

  1410.         # see also LaTeX codec
    1411. 

  1411.         # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/252124
    1412. 

  1412.         # and unimap.py from TeXML
    1413. 

  1413. 

  1414.         # set up the translation table:
    1415. 

  1415.         table = special_chars
    1416. 

  1416.         # keep the underscore in citation references
    1417. 

  1417.         if self.inside_citation_reference_label:
    1418. 

  1418.             del(table[ord('_')])
    1419. 

  1419.         # Workarounds for OT1 font-encoding
    1420. 

  1420.         if self.font_encoding in ['OT1', '']:
    1421. 

  1421.             # * out-of-order characters in cmtt
    1422. 

  1422.             if self.literal:
    1423. 

  1423.                 # replace underscore by underlined blank,
    1424. 

  1424.                 # because this has correct width.
    1425. 

  1425.                 table[ord('_')] = u'\\underline{~}'
    1426. 

  1426.                 # the backslash doesn't work, so we use a mirrored slash.
    1427. 

  1427.                 # \reflectbox is provided by graphicx:
    1428. 

  1428.                 self.requirements['graphicx'] = self.graphicx_package
    1429. 

  1429.                 table[ord('\\')] = ur'\reflectbox{/}'
    1430. 

  1430.             # * ``< | >`` come out as different chars (except for cmtt):
    1431. 

  1431.             else:
    1432. 

  1432.                 table[ord('|')] = ur'\textbar{}'
    1433. 

  1433.                 table[ord('<')] = ur'\textless{}'
    1434. 

  1434.                 table[ord('>')] = ur'\textgreater{}'
    1435. 

  1435.         if self.insert_non_breaking_blanks:
    1436. 

  1436.             table[ord(' ')] = ur'~'
    1437. 

  1437.         if self.literal:
    1438. 

  1438.             # double quotes are 'active' in some languages
    1439. 

  1439.             # TODO: use \textquotedbl if font encoding starts with T?
    1440. 

  1440.             table[ord('"')] = self.babel.literal_double_quote
    1441. 

  1441.         # Unicode chars:
    1442. 

  1442.         table.update(unsupported_unicode_chars)
    1443. 

  1443.         table.update(pifont_chars)
    1444. 

  1444.         if not self.latex_encoding.startswith('utf8'):
    1445. 

  1445.             table.update(unicode_chars)
    1446. 

  1446.             table.update(textcomp_chars)
    1447. 

  1447.         # Characters that require a feature/package to render
    1448. 

  1448.         for ch in text:
    1449. 

  1449.             if ord(ch) in pifont_chars:
    1450. 

  1450.                 self.requirements['pifont'] = '\\usepackage{pifont}'
    1451. 

  1451.             if ord(ch) in textcomp_chars:
    1452. 

  1452.                 self.requirements['textcomp'] = PreambleCmds.textcomp
    1453. 

  1453. 

  1454.         text = text.translate(table)
    1455. 

  1455. 

  1456.         # Break up input ligatures
    1457. 

  1457.         for char in separate_chars * 2:
    1458. 

  1458.             # Do it twice ("* 2") because otherwise we would replace
    1459. 

  1459.             # '---' by '-{}--'.
    1460. 

  1460.             text = text.replace(char + char, char + '{}' + char)
    1461. 

  1461.         # Literal line breaks (in address or literal blocks):
    1462. 

  1462.         if self.insert_newline:
    1463. 

  1463.             lines = text.split('\n')
    1464. 

  1464.             # for blank lines, insert a protected space, to avoid
    1465. 

  1465.             # ! LaTeX Error: There's no line here to end.
    1466. 

  1466.             lines = [line + '~'*(not line.lstrip())
    1467. 

  1467.                      for line in lines[:-1]] + lines[-1:]
    1468. 

  1468.             text = '\\\\\n'.join(lines)
    1469. 

  1469.         if not self.literal:
    1470. 

  1470.             text = self.babel.quote_quotes(text)
    1471. 

  1471.         if self.literal and not self.insert_non_breaking_blanks:
    1472. 

  1472.             # preserve runs of spaces but allow wrapping
    1473. 

  1473.             text = text.replace('  ', ' ~')
    1474. 

  1474.         if not self.latex_encoding.startswith('utf8'):
    1475. 

  1475.             text = self.ensure_math(text)
    1476. 

  1476.         return text
    1477. 

  1477. 

  1478.     def attval(self, text,
    1479. 

  1479.                whitespace=re.compile('[\n\r\t\v\f]')):
    1480. 

  1480.         """Cleanse, encode, and return attribute value text."""
    1481. 

  1481.         return self.encode(whitespace.sub(' ', text))
    1482. 

  1482. 

  1483.     # TODO: is this used anywhere? -> update (use template) or delete
    1484. 

  1484.     ## def astext(self):
    1485. 

  1485.     ##     """Assemble document parts and return as string."""
    1486. 

  1486.     ##     head = '\n'.join(self.head_prefix + self.stylesheet + self.head)
    1487. 

  1487.     ##     body = ''.join(self.body_prefix  + self.body + self.body_suffix)
    1488. 

  1488.     ##     return head + '\n' + body
    1489. 

  1489. 

  1490.     def is_inline(self, node):
    1491. 

  1491.         """Check whether a node represents an inline element"""
    1492. 

  1492.         return isinstance(node.parent, nodes.TextElement)
    1493. 

  1493. 

  1494.     def append_hypertargets(self, node):
    1495. 

  1495.         """Append hypertargets for all ids of `node`"""
    1496. 

  1496.         # hypertarget places the anchor at the target's baseline,
    1497. 

  1497.         # so we raise it explicitely
    1498. 

  1498.         self.out.append('%\n'.join(['\\raisebox{1em}{\\hypertarget{%s}{}}' %
    1499. 

  1499.                                     id for id in node['ids']]))
    1500. 

  1500. 

  1501.     def ids_to_labels(self, node, set_anchor=True):
    1502. 

  1502.         """Return list of label definitions for all ids of `node`
    1503. 

    1504. 

  1504.         If `set_anchor` is True, an anchor is set with \phantomsection.
    1505. 

  1505.         """
    1506. 

  1506.         labels = ['\\label{%s}' % id for id in node.get('ids', [])]
    1507. 

  1507.         # if set_anchor and labels:
    1508. 

  1508.         #    labels.insert(0, '\\phantomsection')
    1509. 

  1509.         return labels
    1510. 

  1510. 

  1511.     def push_output_collector(self, new_out):
    1512. 

  1512.         self.out_stack.append(self.out)
    1513. 

  1513.         self.out = new_out
    1514. 

  1514. 

  1515.     def pop_output_collector(self):
    1516. 

  1516.         self.out = self.out_stack.pop()
    1517. 

  1517. 

  1518.     # Visitor methods
    1519. 

  1519.     # ---------------
    1520. 

  1520. 

  1521.     def visit_Text(self, node):
    1522. 

  1522.         self.out.append(self.encode(node.astext()))
    1523. 

  1523. 

  1524.     def depart_Text(self, node):
    1525. 

  1525.         pass
    1526. 

  1526. 

  1527.     def visit_abbreviation(self, node):
    1528. 

  1528.         node['classes'].insert(0, 'abbreviation')
    1529. 

  1529.         self.visit_inline(node)
    1530. 

  1530. 

  1531.     def depart_abbreviation(self, node):
    1532. 

  1532.         self.depart_inline(node)
    1533. 

  1533. 

  1534.     def visit_acronym(self, node):
    1535. 

  1535.         node['classes'].insert(0, 'acronym')
    1536. 

  1536.         self.visit_inline(node)
    1537. 

  1537. 

  1538.     def depart_acronym(self, node):
    1539. 

  1539.         self.depart_inline(node)
    1540. 

  1540. 

  1541.     def visit_address(self, node):
    1542. 

  1542.         self.visit_docinfo_item(node, 'address')
    1543. 

  1543. 

  1544.     def depart_address(self, node):
    1545. 

  1545.         self.depart_docinfo_item(node)
    1546. 

  1546. 

  1547.     def visit_admonition(self, node):
    1548. 

  1548.         self.fallbacks['admonition'] = PreambleCmds.admonition
    1549. 

  1549.         if 'error' in node['classes']:
    1550. 

  1550.             self.fallbacks['error'] = PreambleCmds.error
    1551. 

  1551.         # strip the generic 'admonition' from the list of classes
    1552. 

  1552.         node['classes'] = [cls for cls in node['classes']
    1553. 

  1553.                            if cls != 'admonition']
    1554. 

  1554.         self.out.append('\n\\DUadmonition[%s]{\n' % ','.join(node['classes']))
    1555. 

  1555. 

  1556.     def depart_admonition(self, node=None):
    1557. 

  1557.         self.out.append('}\n')
    1558. 

  1558. 

  1559.     def visit_author(self, node):
    1560. 

  1560.         self.visit_docinfo_item(node, 'author')
    1561. 

  1561. 

  1562.     def depart_author(self, node):
    1563. 

  1563.         self.depart_docinfo_item(node)
    1564. 

  1564. 

  1565.     def visit_authors(self, node):
    1566. 

  1566.         # not used: visit_author is called anyway for each author.
    1567. 

  1567.         pass
    1568. 

  1568. 

  1569.     def depart_authors(self, node):
    1570. 

  1570.         pass
    1571. 

  1571. 

  1572.     def visit_block_quote(self, node):
    1573. 

  1573.         self.out.append( '%\n\\begin{quote}\n')
    1574. 

  1574.         if node['classes']:
    1575. 

  1575.             self.visit_inline(node)
    1576. 

  1576. 

  1577.     def depart_block_quote(self, node):
    1578. 

  1578.         if node['classes']:
    1579. 

  1579.             self.depart_inline(node)
    1580. 

  1580.         self.out.append( '\n\\end{quote}\n')
    1581. 

  1581. 

  1582.     def visit_bullet_list(self, node):
    1583. 

  1583.         if self.is_toc_list:
    1584. 

  1584.             self.out.append( '%\n\\begin{list}{}{}\n' )
    1585. 

  1585.         else:
    1586. 

  1586.             self.out.append( '%\n\\startitemize\n' )
    1587. 

  1587. 

  1588.     def depart_bullet_list(self, node):
    1589. 

  1589.         if self.is_toc_list:
    1590. 

  1590.             self.out.append( '\n\\end{list}\n' )
    1591. 

  1591.         else:
    1592. 

  1592.             self.out.append( '\n\\stopitemize\n' )
    1593. 

  1593. 

  1594.     def visit_superscript(self, node):
    1595. 

  1595.         self.out.append(r'\textsuperscript{')
    1596. 

  1596.         if node['classes']:
    1597. 

  1597.             self.visit_inline(node)
    1598. 

  1598. 

  1599.     def depart_superscript(self, node):
    1600. 

  1600.         if node['classes']:
    1601. 

  1601.             self.depart_inline(node)
    1602. 

  1602.         self.out.append('}')
    1603. 

  1603. 

  1604.     def visit_subscript(self, node):
    1605. 

  1605.         self.out.append(r'\textsubscript{') # requires `fixltx2e`
    1606. 

  1606.         if node['classes']:
    1607. 

  1607.             self.visit_inline(node)
    1608. 

  1608. 

  1609.     def depart_subscript(self, node):
    1610. 

  1610.         if node['classes']:
    1611. 

  1611.             self.depart_inline(node)
    1612. 

  1612.         self.out.append('}')
    1613. 

  1613. 

  1614.     def visit_caption(self, node):
    1615. 

  1615.         self.out.append( '\\caption{' )
    1616. 

  1616. 

  1617.     def depart_caption(self, node):
    1618. 

  1618.         self.out.append('}\n')
    1619. 

  1619. 

  1620.     def visit_title_reference(self, node):
    1621. 

  1621.         self.fallbacks['titlereference'] = PreambleCmds.titlereference
    1622. 

  1622.         self.out.append(r'\DUroletitlereference{')
    1623. 

  1623.         if node['classes']:
    1624. 

  1624.             self.visit_inline(node)
    1625. 

  1625. 

  1626.     def depart_title_reference(self, node):
    1627. 

  1627.         if node['classes']:
    1628. 

  1628.             self.depart_inline(node)
    1629. 

  1629.         self.out.append( '}' )
    1630. 

  1630. 

  1631.     def visit_citation(self, node):
    1632. 

  1632.         # TODO maybe use cite bibitems
    1633. 

  1633.         if self._use_latex_citations:
    1634. 

  1634.             self.push_output_collector([])
    1635. 

  1635.         else:
    1636. 

  1636.             # TODO: do we need these?
    1637. 

  1637.             ## self.requirements['~fnt_floats'] = PreambleCmds.footnote_floats
    1638. 

  1638.             self.out.append(r'\begin{figure}[b]')
    1639. 

  1639.             self.append_hypertargets(node)
    1640. 

  1640. 

  1641.     def depart_citation(self, node):
    1642. 

  1642.         if self._use_latex_citations:
    1643. 

  1643.             label = self.out[0]
    1644. 

  1644.             text = ''.join(self.out[1:])
    1645. 

  1645.             self._bibitems.append([label, text])
    1646. 

  1646.             self.pop_output_collector()
    1647. 

  1647.         else:
    1648. 

  1648.             self.out.append('\\end{figure}\n')
    1649. 

  1649. 

  1650.     def visit_citation_reference(self, node):
    1651. 

  1651.         if self._use_latex_citations:
    1652. 

  1652.             if not self.inside_citation_reference_label:
    1653. 

  1653.                 self.out.append(r'\cite{')
    1654. 

  1654.                 self.inside_citation_reference_label = 1
    1655. 

  1655.             else:
    1656. 

  1656.                 assert self.body[-1] in (' ', '\n'),\
    1657. 

  1657.                         'unexpected non-whitespace while in reference label'
    1658. 

  1658.                 del self.body[-1]
    1659. 

  1659.         else:
    1660. 

  1660.             href = ''
    1661. 

  1661.             if 'refid' in node:
    1662. 

  1662.                 href = node['refid']
    1663. 

  1663.             elif 'refname' in node:
    1664. 

  1664.                 href = self.document.nameids[node['refname']]
    1665. 

  1665.             self.out.append('\\hyperlink{%s}{[' % href)
    1666. 

  1666. 

  1667.     def depart_citation_reference(self, node):
    1668. 

  1668.         if self._use_latex_citations:
    1669. 

  1669.             followup_citation = False
    1670. 

  1670.             # check for a following citation separated by a space or newline
    1671. 

  1671.             next_siblings = node.traverse(descend=0, siblings=1,
    1672. 

  1672.                                           include_self=0)
    1673. 

  1673.             if len(next_siblings) > 1:
    1674. 

  1674.                 next = next_siblings[0]
    1675. 

  1675.                 if (isinstance(next, nodes.Text) and
    1676. 

  1676.                     next.astext() in (' ', '\n')):
    1677. 

  1677.                     if next_siblings[1].__class__ == node.__class__:
    1678. 

  1678.                         followup_citation = True
    1679. 

  1679.             if followup_citation:
    1680. 

  1680.                 self.out.append(',')
    1681. 

  1681.             else:
    1682. 

  1682.                 self.out.append('}')
    1683. 

  1683.                 self.inside_citation_reference_label = False
    1684. 

  1684.         else:
    1685. 

  1685.             self.out.append(']}')
    1686. 

  1686. 

  1687.     def visit_classifier(self, node):
    1688. 

  1688.         self.out.append( '({\\bf ' )
    1689. 

  1689. 

  1690.     def depart_classifier(self, node):
    1691. 

  1691.         self.out.append( '})\n' )
    1692. 

  1692. 

  1693.     def visit_colspec(self, node):
    1694. 

  1694.         self.active_table.visit_colspec(node)
    1695. 

  1695. 

  1696.     def depart_colspec(self, node):
    1697. 

  1697.         pass
    1698. 

  1698. 

  1699.     def visit_comment(self, node):
    1700. 

  1700.         # Precede every line with a comment sign, wrap in newlines
    1701. 

  1701.         self.out.append('\n%% %s\n' % node.astext().replace('\n', '\n% '))
    1702. 

  1702.         raise nodes.SkipNode
    1703. 

  1703. 

  1704.     def depart_comment(self, node):
    1705. 

  1705.         pass
    1706. 

  1706. 

  1707.     def visit_compound(self, node):
    1708. 

  1708.         pass
    1709. 

  1709. 

  1710.     def depart_compound(self, node):
    1711. 

  1711.         pass
    1712. 

  1712. 

  1713.     def visit_contact(self, node):
    1714. 

  1714.         self.visit_docinfo_item(node, 'contact')
    1715. 

  1715. 

  1716.     def depart_contact(self, node):
    1717. 

  1717.         self.depart_docinfo_item(node)
    1718. 

  1718. 

  1719.     def visit_container(self, node):
    1720. 

  1720.         pass
    1721. 

  1721. 

  1722.     def depart_container(self, node):
    1723. 

  1723.         pass
    1724. 

  1724. 

  1725.     def visit_copyright(self, node):
    1726. 

  1726.         self.visit_docinfo_item(node, 'copyright')
    1727. 

  1727. 

  1728.     def depart_copyright(self, node):
    1729. 

  1729.         self.depart_docinfo_item(node)
    1730. 

  1730. 

  1731.     def visit_date(self, node):
    1732. 

  1732.         self.visit_docinfo_item(node, 'date')
    1733. 

  1733. 

  1734.     def depart_date(self, node):
    1735. 

  1735.         self.depart_docinfo_item(node)
    1736. 

  1736. 

  1737.     def visit_decoration(self, node):
    1738. 

  1738.         # header and footer
    1739. 

  1739.         pass
    1740. 

  1740. 

  1741.     def depart_decoration(self, node):
    1742. 

  1742.         pass
    1743. 

  1743. 

  1744.     def visit_definition(self, node):
    1745. 

  1745.         pass
    1746. 

  1746. 

  1747.     def depart_definition(self, node):
    1748. 

  1748.         self.out.append('\n')
    1749. 

  1749. 

  1750.     def visit_definition_list(self, node):
    1751. 

  1751.         self.out.append( '%\n\\begin{description}\n' )
    1752. 

  1752. 

  1753.     def depart_definition_list(self, node):
    1754. 

  1754.         self.out.append( '\\end{description}\n' )
    1755. 

  1755. 

  1756.     def visit_definition_list_item(self, node):
    1757. 

  1757.         pass
    1758. 

  1758. 

  1759.     def depart_definition_list_item(self, node):
    1760. 

  1760.         pass
    1761. 

  1761. 

  1762.     def visit_description(self, node):
    1763. 

  1763.         self.out.append(' ')
    1764. 

  1764. 

  1765.     def depart_description(self, node):
    1766. 

  1766.         pass
    1767. 

  1767. 

  1768.     def visit_docinfo(self, node):
    1769. 

  1769.         self.push_output_collector(self.docinfo)
    1770. 

  1770. 

  1771.     def depart_docinfo(self, node):
    1772. 

  1772.         self.pop_output_collector()
    1773. 

  1773.         # Some itmes (e.g. author) end up at other places
    1774. 

  1774.         if self.docinfo:
    1775. 

  1775.             # tabularx: automatic width of columns, no page breaks allowed.
    1776. 

  1776.             self.requirements['tabularx'] = r'\usepackage{tabularx}'
    1777. 

  1777.             self.fallbacks['_providelength'] = PreambleCmds.providelength
    1778. 

  1778.             self.fallbacks['docinfo'] = PreambleCmds.docinfo
    1779. 

  1779.             #
    1780. 

  1780.             self.docinfo.insert(0, '\n% Docinfo\n'
    1781. 

  1781.                                 '\\begin{center}\n'
    1782. 

  1782.                                 '\\begin{tabularx}{\\DUdocinfowidth}{lX}\n')
    1783. 

  1783.             self.docinfo.append('\\end{tabularx}\n'
    1784. 

  1784.                                 '\\end{center}\n')
    1785. 

  1785. 

  1786.     def visit_docinfo_item(self, node, name):
    1787. 

  1787.         if name == 'author':
    1788. 

  1788.             self.pdfauthor.append(self.attval(node.astext()))
    1789. 

  1789.         if self.use_latex_docinfo:
    1790. 

  1790.             ## if name in ('author', 'organization', 'contact', 'address'):
    1791. 

  1791.             ##     # We attach these to the last author.  If any of them precedes
    1792. 

  1792.             ##     # the first author, put them in a separate "author" group
    1793. 

  1793.             ##     # (in lack of better semantics).
    1794. 

  1794.             ##     if name == 'author' or not self.author_stack:
    1795. 

  1795.             ##         self.author_stack.append([])
    1796. 

  1796.             ##     if name == 'address':   # newlines are meaningful
    1797. 

  1797.             ##         self.insert_newline = True
    1798. 

  1798.             ##         text = self.encode(node.astext())
    1799. 

  1799.             ##         self.insert_newline = False
    1800. 

  1800.             ##     else:
    1801. 

  1801.             ##         text = self.attval(node.astext())
    1802. 

  1802.             ##     self.author_stack[-1].append(text)
    1803. 

  1803.             ##     raise nodes.SkipNode
    1804. 

  1804.             if name == 'date':
    1805. 

  1805.                 self.date.append(self.attval(node.astext()))
    1806. 

  1806.                 raise nodes.SkipNode
    1807. 

  1807.         self.out.append('{\\bf %s}: &\n\t' % self.language_label(name))
    1808. 

  1808.         if name == 'address':
    1809. 

  1809.             self.insert_newline = 1
    1810. 

  1810.             self.out.append('{\\raggedright\n')
    1811. 

  1811.             self.context.append(' } \\\\\n')
    1812. 

  1812.         else:
    1813. 

  1813.             self.context.append(' \\\\\n')
    1814. 

  1814. 

  1815.     def depart_docinfo_item(self, node):
    1816. 

  1816.         self.out.append(self.context.pop())
    1817. 

  1817.         # for address we did set insert_newline
    1818. 

  1818.         self.insert_newline = False
    1819. 

  1819. 

  1820.     def visit_doctest_block(self, node):
    1821. 

  1821.         self.visit_literal_block(node)
    1822. 

  1822. 

  1823.     def depart_doctest_block(self, node):
    1824. 

  1824.         self.depart_literal_block(node)
    1825. 

  1825. 

  1826.     def visit_document(self, node):
    1827. 

  1827.         # titled document?
    1828. 

  1828.         if (self.use_latex_docinfo or len(node) and
    1829. 

  1829.             isinstance(node[0], nodes.title)):
    1830. 

  1830.             self.title_labels += self.ids_to_labels(node, set_anchor=False)
    1831. 

  1831. 

  1832.     def depart_document(self, node):
    1833. 

  1833.         # Complete header with information gained from walkabout
    1834. 

  1834.         # * language setup
    1835. 

  1835.         if (self.babel.otherlanguages or
    1836. 

  1836.             self.babel.language not in ('', 'english')):
    1837. 

  1837.             self.requirements['babel'] = self.babel()
    1838. 

  1838.         # * conditional requirements (before style sheet)
    1839. 

  1839.         self.requirements = self.requirements.sortedvalues()
    1840. 

  1840.         # * coditional fallback definitions (after style sheet)
    1841. 

  1841.         self.fallbacks = self.fallbacks.sortedvalues()
    1842. 

  1842.         # * PDF properties
    1843. 

  1843.         # self.pdfsetup.append(PreambleCmds.linking % self.hyperref_options)
    1844. 

  1844.         # if self.pdfauthor:
    1845. 

  1845.         #     authors = self.author_separator.join(self.pdfauthor)
    1846. 

  1846.         #     self.pdfinfo.append('  pdfauthor={%s}' % authors)
    1847. 

  1847.         # if self.pdfinfo:
    1848. 

  1848.         #     self.pdfsetup += [r'\hypersetup{'] + self.pdfinfo + ['}']
    1849. 

  1849.         # Complete body
    1850. 

  1850.         # * document title (with "use_latex_docinfo" also
    1851. 

  1851.         #   'author', 'organization', 'contact', 'address' and 'date')
    1852. 

  1852.         ## if self.title or (
    1853. 

  1853.         ##    self.use_latex_docinfo and (self.author_stack or self.date)):
    1854. 

  1854.         ##     # with the default template, titledata is written to the preamble
    1855. 

  1855.         ##     self.titledata.append('%%% Title Data')
    1856. 

  1856.         ##     # \title (empty \title prevents error with \maketitle)
    1857. 

  1857.         ##     #if self.title:
    1858. 

  1858.         ##     #    self.title.insert(0, '\phantomsection%\n  ')
    1859. 

  1859.         ##     title = [''.join(self.title)] + self.title_labels
    1860. 

  1860.         ##     if self.subtitle:
    1861. 

  1861.         ##         title += [r'\\ % subtitle',
    1862. 

  1862.         ##                      r'\large{%s}' % ''.join(self.subtitle)
    1863. 

  1863.         ##                  ] + self.subtitle_labels
    1864. 

  1864.         ##     self.titledata.append(r'\title{%s}' % '%\n  '.join(title))
    1865. 

  1865.         ##     # \author (empty \author prevents warning with \maketitle)
    1866. 

  1866.         ##     authors = ['\\\\\n'.join(author_entry)
    1867. 

  1867.         ##                 for author_entry in self.author_stack]
    1868. 

  1868.         ##     self.titledata.append(r'\author{%s}' %
    1869. 

  1869.         ##                               ' \\and\n'.join(authors))
    1870. 

  1870.         ##     # \date (empty \date prevents defaulting to \today)
    1871. 

  1871.         ##     self.titledata.append(r'\date{%s}' % ', '.join(self.date))
    1872. 

  1872.         ##     # \maketitle in the body formats title with LaTeX
    1873. 

  1873.         ##     self.body_pre_docinfo.append('\\maketitle\n')
    1874. 

  1874. 

  1875.         # * bibliography
    1876. 

  1876.         #   TODO insertion point of bibliography should be configurable.
    1877. 

  1877.         if self._use_latex_citations and len(self._bibitems)>0:
    1878. 

  1878.             if not self.bibtex:
    1879. 

  1879.                 widest_label = ''
    1880. 

  1880.                 for bi in self._bibitems:
    1881. 

  1881.                     if len(widest_label)<len(bi[0]):
    1882. 

  1882.                         widest_label = bi[0]
    1883. 

  1883.                 self.out.append('\n\\begin{thebibliography}{%s}\n' %
    1884. 

  1884.                                  widest_label)
    1885. 

  1885.                 for bi in self._bibitems:
    1886. 

  1886.                     # cite_key: underscores must not be escaped
    1887. 

  1887.                     cite_key = bi[0].replace(r'\_','_')
    1888. 

  1888.                     self.out.append('\\bibitem[%s]{%s}{%s}\n' %
    1889. 

  1889.                                      (bi[0], cite_key, bi[1]))
    1890. 

  1890.                 self.out.append('\\end{thebibliography}\n')
    1891. 

  1891.             else:
    1892. 

  1892.                 self.out.append('\n\\bibliographystyle{%s}\n' %
    1893. 

  1893.                                 self.bibtex[0])
    1894. 

  1894.                 self.out.append('\\bibliography{%s}\n' % self.bibtex[1])
    1895. 

  1895.         # * make sure to generate a toc file if needed for local contents:
    1896. 

  1896.         if 'minitoc' in self.requirements and not self.has_latex_toc:
    1897. 

  1897.             self.out.append('\n\\faketableofcontents % for local ToCs\n')
    1898. 

  1898. 

  1899.     def visit_emphasis(self, node):
    1900. 

  1900.         self.out.append('{\\it ')
    1901. 

  1901.         if node['classes']:
    1902. 

  1902.             self.visit_inline(node)
    1903. 

  1903. 

  1904.     def depart_emphasis(self, node):
    1905. 

  1905.         if node['classes']:
    1906. 

  1906.             self.depart_inline(node)
    1907. 

  1907.         self.out.append('}')
    1908. 

  1908. 

  1909.     def visit_entry(self, node):
    1910. 

  1910.         self.active_table.visit_entry()
    1911. 

  1911.         # cell separation
    1912. 

  1912.         # BUG: the following fails, with more than one multirow
    1913. 

  1913.         # starting in the second column (or later) see
    1914. 

  1914.         # ../../../test/functional/input/data/latex.txt
    1915. 

  1915.         if self.active_table.get_entry_number() == 1:
    1916. 

  1916.             # if the first row is a multirow, this actually is the second row.
    1917. 

  1917.             # this gets hairy if rowspans follow each other.
    1918. 

  1918.             if self.active_table.get_rowspan(0):
    1919. 

  1919.                 count = 0
    1920. 

  1920.                 while self.active_table.get_rowspan(count):
    1921. 

  1921.                     count += 1
    1922. 

  1922.                     self.out.append(' & ')
    1923. 

  1923.                 self.active_table.visit_entry() # increment cell count
    1924. 

  1924.         else:
    1925. 

  1925.             self.out.append(' & ')
    1926. 

  1926.         # multirow, multicolumn
    1927. 

  1927.         # IN WORK BUG TODO HACK continues here
    1928. 

  1928.         # multirow in LaTeX simply will enlarge the cell over several rows
    1929. 

  1929.         # (the following n if n is positive, the former if negative).
    1930. 

  1930.         if 'morerows' in node and 'morecols' in node:
    1931. 

  1931.             raise NotImplementedError('Cells that '
    1932. 

  1932.             'span multiple rows *and* columns are not supported, sorry.')
    1933. 

  1933.         if 'morerows' in node:
    1934. 

  1934.             self.requirements['multirow'] = r'\usepackage{multirow}'
    1935. 

  1935.             count = node['morerows'] + 1
    1936. 

  1936.             self.active_table.set_rowspan(
    1937. 

  1937.                                 self.active_table.get_entry_number()-1,count)
    1938. 

  1938.             self.out.append('\\multirow{%d}{%s}{%%' %
    1939. 

  1939.                             (count,self.active_table.get_column_width()))
    1940. 

  1940.             self.context.append('}')
    1941. 

  1941.         elif 'morecols' in node:
    1942. 

  1942.             # the vertical bar before column is missing if it is the first
    1943. 

  1943.             # column. the one after always.
    1944. 

  1944.             if self.active_table.get_entry_number() == 1:
    1945. 

  1945.                 bar1 = self.active_table.get_vertical_bar()
    1946. 

  1946.             else:
    1947. 

  1947.                 bar1 = ''
    1948. 

  1948.             count = node['morecols'] + 1
    1949. 

  1949.             self.out.append('\\multicolumn{%d}{%sp{%s}%s}{' %
    1950. 

  1950.                     (count, bar1,
    1951. 

  1951.                      self.active_table.get_multicolumn_width(
    1952. 

  1952.                         self.active_table.get_entry_number(),
    1953. 

  1953.                         count),
    1954. 

  1954.                      self.active_table.get_vertical_bar()))
    1955. 

  1955.             self.context.append('}')
    1956. 

  1956.         else:
    1957. 

  1957.             self.context.append('')
    1958. 

  1958. 

  1959.         # header / not header
    1960. 

  1960.         if isinstance(node.parent.parent, nodes.thead):
    1961. 

  1961.             self.out.append('{\\bf %')
    1962. 

  1962.             self.context.append('}')
    1963. 

  1963.         elif self.active_table.is_stub_column():
    1964. 

  1964.             self.out.append('{\\bf{ ')
    1965. 

  1965.             self.context.append('}')
    1966. 

  1966.         else:
    1967. 

  1967.             self.context.append('')
    1968. 

  1968. 

  1969.     def depart_entry(self, node):
    1970. 

  1970.         self.out.append(self.context.pop()) # header / not header
    1971. 

  1971.         self.out.append(self.context.pop()) # multirow/column
    1972. 

  1972.         # if following row is spanned from above.
    1973. 

  1973.         if self.active_table.get_rowspan(self.active_table.get_entry_number()):
    1974. 

  1974.            self.out.append(' & ')
    1975. 

  1975.            self.active_table.visit_entry() # increment cell count
    1976. 

  1976. 

  1977.     def visit_row(self, node):
    1978. 

  1978.         self.active_table.visit_row()
    1979. 

  1979. 

  1980.     def depart_row(self, node):
    1981. 

  1981.         self.out.extend(self.active_table.depart_row())
    1982. 

  1982. 

  1983.     def visit_enumerated_list(self, node):
    1984. 

  1984.         # We create our own enumeration list environment.
    1985. 

  1985.         # This allows to set the style and starting value
    1986. 

  1986.         # and unlimited nesting.
    1987. 

  1987.         enum_style = {'arabic':'n',
    1988. 

  1988.                 'loweralpha':'a',
    1989. 

  1989.                 'upperalpha':'A',
    1990. 

  1990.                 'lowerroman':'r',
    1991. 

  1991.                 'upperroman':'R' }
    1992. 

  1992.         enum_suffix = ''
    1993. 

  1993.         if 'suffix' in node:
    1994. 

  1994.             enum_suffix = node['suffix']
    1995. 

  1995.         enum_prefix = ''
    1996. 

  1996.         if 'prefix' in node:
    1997. 

  1997.             enum_prefix = node['prefix']
    1998. 

  1998.         if self.compound_enumerators:
    1999. 

  1999.             pref = ''
    2000. 

  2000.             if self.section_prefix_for_enumerators and self.section_level:
    2001. 

  2001.                 for i in range(self.section_level):
    2002. 

  2002.                     pref += '%d.' % self._section_number[i]
    2003. 

  2003.                 pref = pref[:-1] + self.section_enumerator_separator
    2004. 

  2004.                 enum_prefix += pref
    2005. 

  2005.             for ctype, cname in self._enumeration_counters:
    2006. 

  2006.                 enum_prefix += '\\%s{%s}.' % (ctype, cname)
    2007. 

  2007.         enum_type = 'n' # arabic
    2008. 

  2008.         if 'enumtype' in node:
    2009. 

  2009.             enum_type = node['enumtype']
    2010. 

  2010.         if enum_type in enum_style:
    2011. 

  2011.             enum_type = enum_style[enum_type]
    2012. 

  2012. 

  2013.         counter_name = 'listcnt%d' % len(self._enumeration_counters)
    2014. 

  2014.         self._enumeration_counters.append((enum_type, counter_name))
    2015. 

  2015.         # If we haven't used this counter name before, then create a
    2016. 

  2016.         # new counter; otherwise, reset & reuse the old counter.
    2017. 

  2017.         ## if len(self._enumeration_counters) > self._max_enumeration_counters:
    2018. 

  2018.         ##     self._max_enumeration_counters = len(self._enumeration_counters)
    2019. 

  2019.         ##     self.out.append('\\newcounter{%s}\n' % counter_name)
    2020. 

  2020.         ## else:
    2021. 

  2021.         ##     self.out.append('\\setcounter{%s}{0}\n' % counter_name)
    2022. 

  2022. 

  2023.         #self.out.append('\\startitemize[%s]{%s\\%s{%s}%s}\n' %
    2024. 

  2024.         #                (enum_prefix,enum_type,counter_name,enum_suffix))
    2025. 

  2025.         self.out.append('\\startitemize[%s]\n' %
    2026. 

  2026.                     (enum_type))
    2027. 

  2027. 

  2028.         # self.out.append('{\n')
    2029. 

  2029.         # self.out.append('\\usecounter{%s}\n' % counter_name)
    2030. 

  2030.         # set start after usecounter, because it initializes to zero.
    2031. 

  2031.         #if 'start' in node:
    2032. 

  2032.         #    self.out.append('\\addtocounter{%s}{%d}\n' %
    2033. 

  2033.         #                    (counter_name,node['start']-1))
    2034. 

  2034.         ## set rightmargin equal to leftmargin
    2035. 

  2035.         #self.out.append('\\setlength{\\rightmargin}{\\leftmargin}\n')
    2036. 

  2036.         #self.out.append('}\n')
    2037. 

  2037. 

  2038.     def depart_enumerated_list(self, node):
    2039. 

  2039.         self.out.append('\\stopitemize\n')
    2040. 

  2040.         self._enumeration_counters.pop()
    2041. 

  2041. 

  2042.     def visit_field(self, node):
    2043. 

  2043.         # real output is done in siblings: _argument, _body, _name
    2044. 

  2044.         pass
    2045. 

  2045. 

  2046.     def depart_field(self, node):
    2047. 

  2047.         self.out.append('\n')
    2048. 

  2048.         ##self.out.append('%[depart_field]\n')
    2049. 

  2049. 

  2050.     def visit_field_argument(self, node):
    2051. 

  2051.         self.out.append('%[visit_field_argument]\n')
    2052. 

  2052. 

  2053.     def depart_field_argument(self, node):
    2054. 

  2054.         self.out.append('%[depart_field_argument]\n')
    2055. 

  2055. 

  2056.     def visit_field_body(self, node):
    2057. 

  2057.         pass
    2058. 

  2058. 

  2059.     def depart_field_body(self, node):
    2060. 

  2060.         if self.out is self.docinfo:
    2061. 

  2061.             self.out.append(r'\\')
    2062. 

  2062. 

  2063.     def visit_field_list(self, node):
    2064. 

  2064.         if self.out is not self.docinfo:
    2065. 

  2065.             self.fallbacks['fieldlist'] = PreambleCmds.fieldlist
    2066. 

  2066.             self.out.append('%\n\\begin{DUfieldlist}\n')
    2067. 

  2067. 

  2068.     def depart_field_list(self, node):
    2069. 

  2069.         if self.out is not self.docinfo:
    2070. 

  2070.             self.out.append('\\end{DUfieldlist}\n')
    2071. 

  2071. 

  2072.     def visit_field_name(self, node):
    2073. 

  2073.         if self.out is self.docinfo:
    2074. 

  2074.             self.out.append('{\\bf ')
    2075. 

  2075.         else:
    2076. 

  2076.             # Commands with optional args inside an optional arg must be put
    2077. 

  2077.             # in a group, e.g. ``\item[{\hyperref[label]{text}}]``.
    2078. 

  2078.             self.out.append('\\item[{')
    2079. 

  2079. 

  2080.     def depart_field_name(self, node):
    2081. 

  2081.         if self.out is self.docinfo:
    2082. 

  2082.             self.out.append('}: &')
    2083. 

  2083.         else:
    2084. 

  2084.             self.out.append(':}]')
    2085. 

  2085. 

  2086.     def visit_figure(self, node):
    2087. 

  2087.         self.requirements['float_settings'] = PreambleCmds.float_settings
    2088. 

  2088.         # ! the 'align' attribute should set "outer alignment" !
    2089. 

  2089.         # For "inner alignment" use LaTeX default alignment (similar to HTML)
    2090. 

  2090.         ## if ('align' not in node.attributes or
    2091. 

  2091.         ##     node.attributes['align'] == 'center'):
    2092. 

  2092.         ##     align = '\n\\centering'
    2093. 

  2093.         ##     align_end = ''
    2094. 

  2094.         ## else:
    2095. 

  2095.         ##     # TODO non vertical space for other alignments.
    2096. 

  2096.         ##     align = '\\begin{flush%s}' % node.attributes['align']
    2097. 

  2097.         ##     align_end = '\\end{flush%s}' % node.attributes['align']
    2098. 

  2098.         ## self.out.append( '\\begin{figure}%s\n' % align )
    2099. 

  2099.         ## self.context.append( '%s\\end{figure}\n' % align_end )
    2100. 

  2100.         self.out.append('\\begin{figure}')
    2101. 

  2101.         if node.get('ids'):
    2102. 

  2102.             self.out += ['\n'] + self.ids_to_labels(node)
    2103. 

  2103. 

  2104.     def depart_figure(self, node):
    2105. 

  2105.         self.out.append('\\end{figure}\n')
    2106. 

  2106. 

  2107.     def visit_footer(self, node):
    2108. 

  2108.         self.push_output_collector([])
    2109. 

  2109.         self.out.append(r'\newcommand{\DUfooter}{')
    2110. 

  2110. 

  2111.     def depart_footer(self, node):
    2112. 

  2112.         self.out.append('}')
    2113. 

  2113.         self.requirements['~footer'] = ''.join(self.out)
    2114. 

  2114.         self.pop_output_collector()
    2115. 

  2115. 

  2116.     def visit_footnote(self, node):
    2117. 

  2117.         try:
    2118. 

  2118.             backref = node['backrefs'][0]
    2119. 

  2119.         except IndexError:
    2120. 

  2120.             backref = node['ids'][0] # no backref, use self-ref instead
    2121. 

  2121.         if self.settings.figure_footnotes:
    2122. 

  2122.             # self.requirements['~fnt_floats'] = PreambleCmds.footnote_floats
    2123. 

  2123.             self.out.append('\\begin{figure}[b]')
    2124. 

  2124.             self.append_hypertargets(node)
    2125. 

  2125.             if node.get('id') == node.get('name'):  # explicite label
    2126. 

  2126.                 self.out += self.ids_to_labels(node)
    2127. 

  2127.         elif self.docutils_footnotes:
    2128. 

  2128.             # self.fallbacks['footnotes'] = PreambleCmds.footnotes
    2129. 

  2129.             num,text = node.astext().split(None,1)
    2130. 

  2130.             if self.settings.footnote_references == 'brackets':
    2131. 

  2131.                 num = '[%s]' % num
    2132. 

  2132.             # self.out.append('%%\n\\DUfootnotetext{%s}{%s}{%s}{' %
    2133. 

  2133.             #                 (node['ids'][0], backref, self.encode(num)))
    2134. 

  2134.             self.out.append('%%\n\\footnote[%s]' %
    2135. 

  2135.                             (node['ids'][0]))                
    2136. 

  2136.             if node['ids'] == node['names']:
    2137. 

  2137.                 self.out += self.ids_to_labels(node)
    2138. 

  2138.             # mask newline to prevent spurious whitespace:
    2139. 

  2139.             self.out.append('%')
    2140. 

  2140.         ## else:  # TODO: "real" LaTeX \footnote{}s
    2141. 

  2141. 

  2142.     def depart_footnote(self, node):
    2143. 

  2143.         if self.figure_footnotes:
    2144. 

  2144.             self.out.append('\\end{figure}\n')
    2145. 

  2145.         else:
    2146. 

  2146.             self.out.append('}\n')
    2147. 

  2147. 

  2148.     def visit_footnote_reference(self, node):
    2149. 

  2149.         href = ''
    2150. 

  2150.         if 'refid' in node:
    2151. 

  2151.             href = node['refid']
    2152. 

  2152.         elif 'refname' in node:
    2153. 

  2153.             href = self.document.nameids[node['refname']]
    2154. 

  2154.         # if not self.docutils_footnotes:
    2155. 

  2155.             # TODO: insert footnote content at (or near) this place
    2156. 

  2156.             # print "footnote-ref to", node['refid']
    2157. 

  2157.             # footnotes = (self.document.footnotes +
    2158. 

  2158.             #              self.document.autofootnotes +
    2159. 

  2159.             #              self.document.symbol_footnotes)
    2160. 

  2160.             # for footnote in footnotes:
    2161. 

  2161.             #     # print footnote['ids']
    2162. 

  2162.             #     if node.get('refid', '') in footnote['ids']:
    2163. 

  2163.             #         print 'matches', footnote['ids']
    2164. 

  2164.         format = self.settings.footnote_references
    2165. 

  2165.         ## if format == 'brackets':
    2166. 

  2166.         ##     self.append_hypertargets(node)
    2167. 

  2167.         ##     self.out.append('\\hyperlink{%s}{[' % href)
    2168. 

  2168.         ##     self.context.append(']}')
    2169. 

  2169.         ## else:
    2170. 

  2170.         ##     # self.fallbacks['footnotes'] = PreambleCmds.footnotes
    2171. 

  2171.         ##     self.out.append(r'\DUfootnotemark{%s}{%s}{' %
    2172. 

  2172.         ##                     (node['ids'][0], href))
    2173. 

  2173.         ##     self.context.append('}')
    2174. 

  2174.         self.out.append(r'\note[%s]{' % (href))
    2175. 

  2175.         self.context.append('}')
    2176. 

  2176. 

  2177.     def depart_footnote_reference(self, node):
    2178. 

  2178.         self.out.append(self.context.pop())
    2179. 

  2179. 

  2180.     # footnote/citation label
    2181. 

  2181.     def label_delim(self, node, bracket, superscript):
    2182. 

  2182.         if isinstance(node.parent, nodes.footnote):
    2183. 

  2183.             if not self.figure_footnotes:
    2184. 

  2184.                 raise nodes.SkipNode
    2185. 

  2185.             if self.settings.footnote_references == 'brackets':
    2186. 

  2186.                 self.out.append(bracket)
    2187. 

  2187.             else:
    2188. 

  2188.                 self.out.append(superscript)
    2189. 

  2189.         else:
    2190. 

  2190.             assert isinstance(node.parent, nodes.citation)
    2191. 

  2191.             if not self._use_latex_citations:
    2192. 

  2192.                 self.out.append(bracket)
    2193. 

  2193. 

  2194.     def visit_label(self, node):
    2195. 

  2195.         """footnote or citation label: in brackets or as superscript"""
    2196. 

  2196.         self.label_delim(node, '[', '\\textsuperscript{')
    2197. 

  2197. 

  2198.     def depart_label(self, node):
    2199. 

  2199.         self.label_delim(node, ']', '}')
    2200. 

  2200. 

  2201.     # elements generated by the framework e.g. section numbers.
    2202. 

  2202.     def visit_generated(self, node):
    2203. 

  2203.         pass
    2204. 

  2204. 

  2205.     def depart_generated(self, node):
    2206. 

  2206.         pass
    2207. 

  2207. 

  2208.     def visit_header(self, node):
    2209. 

  2209.         self.push_output_collector([])
    2210. 

  2210.         self.out.append(r'\newcommand{\DUheader}{')
    2211. 

  2211. 

  2212.     def depart_header(self, node):
    2213. 

  2213.         self.out.append('}')
    2214. 

  2214.         self.requirements['~header'] = ''.join(self.out)
    2215. 

  2215.         self.pop_output_collector()
    2216. 

  2216. 

  2217.     def to_latex_length(self, length_str, pxunit='px'):
    2218. 

  2218.         """Convert `length_str` with rst lenght to LaTeX length
    2219. 

  2219.         """
    2220. 

  2220.         match = re.match('(\d*\.?\d*)\s*(\S*)', length_str)
    2221. 

  2221.         if not match:
    2222. 

  2222.             return length_str
    2223. 

  2223.         value, unit = match.groups()[:2]
    2224. 

  2224.         # no unit or "DTP" points (called 'bp' in TeX):
    2225. 

  2225.         if unit in ('', 'pt'):
    2226. 

  2226.             length_str = '%sbp' % value
    2227. 

  2227.         # percentage: relate to current line width
    2228. 

  2228.         elif unit == '%':
    2229. 

  2229.             length_str = '%.3f\\linewidth' % (float(value)/100.0)
    2230. 

  2230.         elif (unit == 'px') and (pxunit != 'px'):
    2231. 

  2231.             # length unit px not defined in some tex variants (e.g. XeTeX)
    2232. 

  2232.             self.fallbacks['_providelength'] = PreambleCmds.providelength
    2233. 

  2233.             self.fallbacks['px'] = '\n\\DUprovidelength{%s}{1bp}\n' % pxunit
    2234. 

  2234.             length_str = '%s%s' % (value, pxunit)
    2235. 

  2235. 

  2236.         return length_str
    2237. 

  2237. 

  2238.     def visit_image(self, node):
    2239. 

  2239.         self.requirements['graphicx'] = self.graphicx_package
    2240. 

  2240.         attrs = node.attributes
    2241. 

  2241.         # Convert image URI to a local file path and add to dependency list
    2242. 

  2242.         imagepath = urllib.url2pathname(attrs['uri']).replace('\\', '/')
    2243. 

  2243.         self.settings.record_dependencies.add(imagepath)
    2244. 

  2244.         # alignment defaults:
    2245. 

  2245.         if not 'align' in attrs:
    2246. 

  2246.             # Set default align of image in a figure to 'center'
    2247. 

  2247.             if isinstance(node.parent, nodes.figure):
    2248. 

  2248.                 attrs['align'] = 'center'
    2249. 

  2249.             # query 'align-*' class argument
    2250. 

  2250.             for cls in node['classes']:
    2251. 

  2251.                 if cls.startswith('align-'):
    2252. 

  2252.                     attrs['align'] = cls.split('-')[1]
    2253. 

  2253.         # pre- and postfix (prefix inserted in reverse order)
    2254. 

  2254.         pre = []
    2255. 

  2255.         post = []
    2256. 

  2256.         include_graphics_options = []
    2257. 

  2257.         display_style = ('block-', 'inline-')[self.is_inline(node)]
    2258. 

  2258.         align_codes = {
    2259. 

  2259.             # inline images: by default latex aligns the bottom.
    2260. 

  2260.             'bottom': ('', ''),
    2261. 

  2261.             'middle': (r'\raisebox{-0.5\height}{', '}'),
    2262. 

  2262.             'top':    (r'\raisebox{-\height}{', '}'),
    2263. 

  2263.             # block level images:
    2264. 

  2264.             'center': (r'\noindent\makebox[\textwidth][c]{', '}'),
    2265. 

  2265.             'left':   (r'\noindent{', r'\hfill}'),
    2266. 

  2266.             'right':  (r'\noindent{\hfill', '}'),}
    2267. 

  2267.         if 'align' in attrs:
    2268. 

  2268.             try:
    2269. 

  2269.                 align_code = align_codes[attrs['align']]
    2270. 

  2270.                 pre.append(align_code[0])
    2271. 

  2271.                 post.append(align_code[1])
    2272. 

  2272.             except KeyError:
    2273. 

  2273.                 pass                    # TODO: warn?
    2274. 

  2274.         if 'height' in attrs:
    2275. 

  2275.             include_graphics_options.append('height=%s' %
    2276. 

  2276.                             self.to_latex_length(attrs['height']))
    2277. 

  2277.         if 'scale' in attrs:
    2278. 

  2278.             include_graphics_options.append('scale=%f' %
    2279. 

  2279.                                             (attrs['scale'] / 100.0))
    2280. 

  2280.         if 'width' in attrs:
    2281. 

  2281.             include_graphics_options.append('width=%s' %
    2282. 

  2282.                             self.to_latex_length(attrs['width']))
    2283. 

  2283.         if not self.is_inline(node):
    2284. 

  2284.             pre.append('\n')
    2285. 

  2285.             post.append('\n')
    2286. 

  2286.         pre.reverse()
    2287. 

  2287.         self.out.extend(pre)
    2288. 

  2288.         options = ''
    2289. 

  2289.         if include_graphics_options:
    2290. 

  2290.             options = '[%s]' % (','.join(include_graphics_options))
    2291. 

  2291.         self.out.append('\\includegraphics%s{%s}' % (options, imagepath))
    2292. 

  2292.         self.out.extend(post)
    2293. 

  2293. 

  2294.     def depart_image(self, node):
    2295. 

  2295.         if node.get('ids'):
    2296. 

  2296.             self.out += self.ids_to_labels(node) + ['\n']
    2297. 

  2297. 

  2298.     def visit_inline(self, node): # <span>, i.e. custom roles
    2299. 

  2299.         # Make a copy to keep  ``node['classes']`` True if a
    2300. 

  2300.         # language argument is popped (used in conditional calls of
    2301. 

  2301.         # depart_inline()):
    2302. 

  2302.         classes = node['classes'][:]
    2303. 

  2303.         self.context.append('}' * len(classes))
    2304. 

  2304.         # handle language specification:
    2305. 

  2305.         language_tags = [cls for cls in classes
    2306. 

  2306.                          if cls.startswith('language-')]
    2307. 

  2307.         if language_tags:
    2308. 

  2308.             language = self.babel.language_name(language_tags[0][9:])
    2309. 

  2309.             if language:
    2310. 

  2310.                 self.babel.otherlanguages[language] = True
    2311. 

  2311.                 self.out.append(r'\otherlanguage{%s}{' % language)
    2312. 

  2312.                 classes.pop(classes.index(language_tags[0]))
    2313. 

  2313.         if not classes:
    2314. 

  2314.             return
    2315. 

  2315.         # mark up for styling with custom macros
    2316. 

  2316.         if 'align-center' in classes:
    2317. 

  2317.             self.fallbacks['align-center'] = PreambleCmds.align_center
    2318. 

  2318.         self.fallbacks['inline'] = PreambleCmds.inline
    2319. 

  2319.         self.out += [r'\DUrole{%s}{' % cls for cls in classes]
    2320. 

  2320. 

  2321.     def depart_inline(self, node):
    2322. 

  2322.         self.out.append(self.context.pop())
    2323. 

  2323. 

  2324.     def visit_interpreted(self, node):
    2325. 

  2325.         # @@@ Incomplete, pending a proper implementation on the
    2326. 

  2326.         # Parser/Reader end.
    2327. 

  2327.         self.visit_literal(node)
    2328. 

  2328. 

  2329.     def depart_interpreted(self, node):
    2330. 

  2330.         self.depart_literal(node)
    2331. 

  2331. 

  2332.     def visit_legend(self, node):
    2333. 

  2333.         self.fallbacks['legend'] = PreambleCmds.legend
    2334. 

  2334.         self.out.append('\\begin{DUlegend}')
    2335. 

  2335. 

  2336.     def depart_legend(self, node):
    2337. 

  2337.         self.out.append('\\end{DUlegend}\n')
    2338. 

  2338. 

  2339.     def visit_line(self, node):
    2340. 

  2340.         self.out.append('\item[] ')
    2341. 

  2341. 

  2342.     def depart_line(self, node):
    2343. 

  2343.         self.out.append('\n')
    2344. 

  2344. 

  2345.     def visit_line_block(self, node):
    2346. 

  2346.         self.fallbacks['_providelength'] = PreambleCmds.providelength
    2347. 

  2347.         self.fallbacks['lineblock'] = PreambleCmds.lineblock
    2348. 

  2348.         if isinstance(node.parent, nodes.line_block):
    2349. 

  2349.             self.out.append('\\item[]\n'
    2350. 

  2350.                              '\\begin{DUlineblock}{\\DUlineblockindent}\n')
    2351. 

  2351.         else:
    2352. 

  2352.             self.out.append('\n\\begin{DUlineblock}{0em}\n')
    2353. 

  2353.         if node['classes']:
    2354. 

  2354.             self.visit_inline(node)
    2355. 

  2355.             self.out.append('\n')
    2356. 

  2356. 

  2357.     def depart_line_block(self, node):
    2358. 

  2358.         if node['classes']:
    2359. 

  2359.             self.depart_inline(node)
    2360. 

  2360.             self.out.append('\n')
    2361. 

  2361.         self.out.append('\\end{DUlineblock}\n')
    2362. 

  2362. 

  2363.     def visit_list_item(self, node):
    2364. 

  2364.         self.out.append('\n\\item ')
    2365. 

  2365. 

  2366.     def depart_list_item(self, node):
    2367. 

  2367.         pass
    2368. 

  2368. 

  2369.     def visit_literal(self, node):
    2370. 

  2370.         self.literal = True
    2371. 

  2371.         self.out.append('{\\tt ')
    2372. 

  2372.         if node['classes']:
    2373. 

  2373.             self.visit_inline(node)
    2374. 

  2374. 

  2375.     def depart_literal(self, node):
    2376. 

  2376.         self.literal = False
    2377. 

  2377.         if node['classes']:
    2378. 

  2378.             self.depart_inline(node)
    2379. 

  2379.         self.out.append('}')
    2380. 

  2380. 

  2381.     # Literal blocks are used for '::'-prefixed literal-indented
    2382. 

  2382.     # blocks of text, where the inline markup is not recognized,
    2383. 

  2383.     # but are also the product of the "parsed-literal" directive,
    2384. 

  2384.     # where the markup is respected.
    2385. 

  2385.     #
    2386. 

  2386.     # In both cases, we want to use a typewriter/monospaced typeface.
    2387. 

  2387.     # For "real" literal-blocks, we can use \verbatim, while for all
    2388. 

  2388.     # the others we must use \mbox or \alltt.
    2389. 

  2389.     #
    2390. 

  2390.     # We can distinguish between the two kinds by the number of
    2391. 

  2391.     # siblings that compose this node: if it is composed by a
    2392. 

  2392.     # single element, it's either
    2393. 

  2393.     # * a real one,
    2394. 

  2394.     # * a parsed-literal that does not contain any markup, or
    2395. 

  2395.     # * a parsed-literal containing just one markup construct.
    2396. 

  2396.     def is_plaintext(self, node):
    2397. 

  2397.         """Check whether a node can be typeset verbatim"""
    2398. 

  2398.         return (len(node) == 1) and isinstance(node[0], nodes.Text)
    2399. 

  2399. 

  2400.     def visit_literal_block(self, node):
    2401. 

  2401.         """Render a literal block."""
    2402. 

  2402.         # environments and packages to typeset literal blocks
    2403. 

  2403.         packages = {'listing': r'\usepackage{moreverb}',
    2404. 

  2404.                     'lstlisting': r'\usepackage{listings}',
    2405. 

  2405.                     'Verbatim': r'\usepackage{fancyvrb}',
    2406. 

  2406.                     # 'verbatim': '',
    2407. 

  2407.                     'verbatimtab': r'\usepackage{moreverb}'}
    2408. 

  2408. 

  2409.         if not self.active_table.is_open():
    2410. 

  2410.             # no quote inside tables, to avoid vertical space between
    2411. 

  2411.             # table border and literal block.
    2412. 

  2412.             # BUG: fails if normal text preceeds the literal block.
    2413. 

  2413.             self.out.append('%\n\\begin{quote}')
    2414. 

  2414.             self.context.append('\n\\end{quote}\n')
    2415. 

  2415.         else:
    2416. 

  2416.             self.out.append('\n')
    2417. 

  2417.             self.context.append('\n')
    2418. 

  2418.         if self.literal_block_env != '' and self.is_plaintext(node):
    2419. 

  2419.             self.requirements['literal_block'] = packages.get(
    2420. 

  2420.                                                   self.literal_block_env, '')
    2421. 

  2421.             self.verbatim = True
    2422. 

  2422.             self.out.append('\\begin{%s}%s\n' % (self.literal_block_env,
    2423. 

  2423.                                                  self.literal_block_options))
    2424. 

  2424.         else:
    2425. 

  2425.             self.literal = True
    2426. 

  2426.             self.insert_newline = True
    2427. 

  2427.             self.insert_non_breaking_blanks = True
    2428. 

  2428.             self.out.append('{\\ttfamily \\raggedright \\noindent\n')
    2429. 

  2429. 

  2430.     def depart_literal_block(self, node):
    2431. 

  2431.         if self.verbatim:
    2432. 

  2432.             self.out.append('\n\\end{%s}\n' % self.literal_block_env)
    2433. 

  2433.             self.verbatim = False
    2434. 

  2434.         else:
    2435. 

  2435.             self.out.append('\n}')
    2436. 

  2436.             self.insert_non_breaking_blanks = False
    2437. 

  2437.             self.insert_newline = False
    2438. 

  2438.             self.literal = False
    2439. 

  2439.         self.out.append(self.context.pop())
    2440. 

  2440. 

  2441.     ## def visit_meta(self, node):
    2442. 

  2442.     ##     self.out.append('[visit_meta]\n')
    2443. 

  2443.         # TODO: set keywords for pdf?
    2444. 

  2444.         # But:
    2445. 

  2445.         #  The reStructuredText "meta" directive creates a "pending" node,
    2446. 

  2446.         #  which contains knowledge that the embedded "meta" node can only
    2447. 

  2447.         #  be handled by HTML-compatible writers. The "pending" node is
    2448. 

  2448.         #  resolved by the docutils.transforms.components.Filter transform,
    2449. 

  2449.         #  which checks that the calling writer supports HTML; if it doesn't,
    2450. 

  2450.         #  the "pending" node (and enclosed "meta" node) is removed from the
    2451. 

  2451.         #  document.
    2452. 

  2452.         #  --- docutils/docs/peps/pep-0258.html#transformer
    2453. 

  2453. 

  2454.     ## def depart_meta(self, node):
    2455. 

  2455.     ##     self.out.append('[depart_meta]\n')
    2456. 

  2456. 

  2457.     def visit_math(self, node, math_env='$'):
    2458. 

  2458.         """math role"""
    2459. 

  2459.         if node['classes']:
    2460. 

  2460.             self.visit_inline(node)
    2461. 

  2461.         self.requirements['amsmath'] = r'\usepackage{amsmath}'
    2462. 

  2462.         math_code = node.astext().translate(unichar2tex.uni2tex_table)
    2463. 

  2463.         if node.get('ids'):
    2464. 

  2464.             math_code = '\n'.join([math_code] + self.ids_to_labels(node))
    2465. 

  2465.         if math_env == '$':
    2466. 

  2466.             wrapper = u'$%s$'
    2467. 

  2467.         else:
    2468. 

  2468.             wrapper = u'\n'.join(['%%',
    2469. 

  2469.                                  r'\begin{%s}' % math_env,
    2470. 

  2470.                                  '%s',
    2471. 

  2471.                                  r'\end{%s}' % math_env])
    2472. 

  2472.         # print repr(wrapper), repr(math_code)
    2473. 

  2473.         self.out.append(wrapper % math_code)
    2474. 

  2474.         if node['classes']:
    2475. 

  2475.             self.depart_inline(node)
    2476. 

  2476.         # Content already processed:
    2477. 

  2477.         raise nodes.SkipNode
    2478. 

  2478. 

  2479.     def depart_math(self, node):
    2480. 

  2480.         pass # never reached
    2481. 

  2481. 

  2482.     def visit_math_block(self, node):
    2483. 

  2483.         math_env = pick_math_environment(node.astext())
    2484. 

  2484.         self.visit_math(node, math_env=math_env)
    2485. 

  2485. 

  2486.     def depart_math_block(self, node):
    2487. 

  2487.         pass # never reached
    2488. 

  2488. 

  2489.     def visit_option(self, node):
    2490. 

  2490.         if self.context[-1]:
    2491. 

  2491.             # this is not the first option
    2492. 

  2492.             self.out.append(', ')
    2493. 

  2493. 

  2494.     def depart_option(self, node):
    2495. 

  2495.         # flag that the first option is done.
    2496. 

  2496.         self.context[-1] += 1
    2497. 

  2497. 

  2498.     def visit_option_argument(self, node):
    2499. 

  2499.         """Append the delimiter betweeen an option and its argument to body."""
    2500. 

  2500.         self.out.append(node.get('delimiter', ' '))
    2501. 

  2501. 

  2502.     def depart_option_argument(self, node):
    2503. 

  2503.         pass
    2504. 

  2504. 

  2505.     def visit_option_group(self, node):
    2506. 

  2506.         self.out.append('\n\\item[')
    2507. 

  2507.         # flag for first option
    2508. 

  2508.         self.context.append(0)
    2509. 

  2509. 

  2510.     def depart_option_group(self, node):
    2511. 

  2511.         self.context.pop() # the flag
    2512. 

  2512.         self.out.append('] ')
    2513. 

  2513. 

  2514.     def visit_option_list(self, node):
    2515. 

  2515.         self.fallbacks['_providelength'] = PreambleCmds.providelength
    2516. 

  2516.         self.fallbacks['optionlist'] = PreambleCmds.optionlist
    2517. 

  2517.         self.out.append('%\n\\begin{DUoptionlist}\n')
    2518. 

  2518. 

  2519.     def depart_option_list(self, node):
    2520. 

  2520.         self.out.append('\n\\end{DUoptionlist}\n')
    2521. 

  2521. 

  2522.     def visit_option_list_item(self, node):
    2523. 

  2523.         pass
    2524. 

  2524. 

  2525.     def depart_option_list_item(self, node):
    2526. 

  2526.         pass
    2527. 

  2527. 

  2528.     def visit_option_string(self, node):
    2529. 

  2529.         ##self.out.append(self.starttag(node, 'span', '', CLASS='option'))
    2530. 

  2530.         pass
    2531. 

  2531. 

  2532.     def depart_option_string(self, node):
    2533. 

  2533.         ##self.out.append('</span>')
    2534. 

  2534.         pass
    2535. 

  2535. 

  2536.     def visit_organization(self, node):
    2537. 

  2537.         self.visit_docinfo_item(node, 'organization')
    2538. 

  2538. 

  2539.     def depart_organization(self, node):
    2540. 

  2540.         self.depart_docinfo_item(node)
    2541. 

  2541. 

  2542.     def visit_paragraph(self, node):
    2543. 

  2543.         # insert blank line, if the paragraph is not first in a list item
    2544. 

  2544.         # nor follows a non-paragraph node in a compound
    2545. 

  2545.         index = node.parent.index(node)
    2546. 

  2546.         if (index == 0 and (isinstance(node.parent, nodes.list_item) or
    2547. 

  2547.                             isinstance(node.parent, nodes.description))):
    2548. 

  2548.             pass
    2549. 

  2549.         elif (index > 0 and isinstance(node.parent, nodes.compound) and
    2550. 

  2550.               not isinstance(node.parent[index - 1], nodes.paragraph) and
    2551. 

  2551.               not isinstance(node.parent[index - 1], nodes.compound)):
    2552. 

  2552.             pass
    2553. 

  2553.         else:
    2554. 

  2554.             self.out.append('\n')
    2555. 

  2555.         if node.get('ids'):
    2556. 

  2556.             self.out += self.ids_to_labels(node) + ['\n']
    2557. 

  2557.         if node['classes']:
    2558. 

  2558.             self.visit_inline(node)
    2559. 

  2559. 

  2560.     def depart_paragraph(self, node):
    2561. 

  2561.         if node['classes']:
    2562. 

  2562.             self.depart_inline(node)
    2563. 

  2563.         self.out.append('\n')
    2564. 

  2564. 

  2565.     def visit_problematic(self, node):
    2566. 

  2566.         self.requirements['color'] = PreambleCmds.color
    2567. 

  2567.         self.out.append('%\n')
    2568. 

  2568.         self.append_hypertargets(node)
    2569. 

  2569.         self.out.append(r'\hyperlink{%s}{{\bf \color{red}' % node['refid'])
    2570. 

  2570. 

  2571.     def depart_problematic(self, node):
    2572. 

  2572.         self.out.append('}}')
    2573. 

  2573. 

  2574.     def visit_raw(self, node):
    2575. 

  2575.         if not 'latex' in node.get('format', '').split():
    2576. 

  2576.             raise nodes.SkipNode
    2577. 

  2577.         if not self.is_inline(node):
    2578. 

  2578.             self.out.append('\n')
    2579. 

  2579.         if node['classes']:
    2580. 

  2580.             self.visit_inline(node)
    2581. 

  2581.         # append "as-is" skipping any LaTeX-encoding
    2582. 

  2582.         self.verbatim = True
    2583. 

  2583. 

  2584.     def depart_raw(self, node):
    2585. 

  2585.         self.verbatim = False
    2586. 

  2586.         if node['classes']:
    2587. 

  2587.             self.depart_inline(node)
    2588. 

  2588.         if not self.is_inline(node):
    2589. 

  2589.             self.out.append('\n')
    2590. 

  2590. 

  2591.     def has_unbalanced_braces(self, string):
    2592. 

  2592.         """Test whether there are unmatched '{' or '}' characters."""
    2593. 

  2593.         level = 0
    2594. 

  2594.         for ch in string:
    2595. 

  2595.             if ch == '{':
    2596. 

  2596.                 level += 1
    2597. 

  2597.             if ch == '}':
    2598. 

  2598.                 level -= 1
    2599. 

  2599.             if level < 0:
    2600. 

  2600.                 return True
    2601. 

  2601.         return level != 0
    2602. 

  2602. 

  2603.     def visit_reference(self, node):
    2604. 

  2604.         # We need to escape #, \, and % if we use the URL in a command.
    2605. 

  2605.         special_chars = {ord('#'): ur'\#',
    2606. 

  2606.                          ord('%'): ur'\%',
    2607. 

  2607.                          ord('\\'): ur'\\',
    2608. 

  2608.                         }
    2609. 

  2609.         # external reference (URL)
    2610. 

  2610.         if 'refuri' in node:
    2611. 

  2611.             href = unicode(node['refuri']).translate(special_chars)
    2612. 

  2612.             # problematic chars double caret and unbalanced braces:
    2613. 

  2613.             if href.find('^^') != -1 or self.has_unbalanced_braces(href):
    2614. 

  2614.                 self.error(
    2615. 

  2615.                     'External link "%s" not supported by LaTeX.\n'
    2616. 

  2616.                     ' (Must not contain "^^" or unbalanced braces.)' % href)
    2617. 

  2617.             if node['refuri'] == node.astext():
    2618. 

  2618.                 # \def\href#1#2{\useURL[#2][{#2}][][{#1}]\goto{\url[#2]}[url(#1)]} 
    2619. 

  2619.                 # self.out.append(r'\url{%s}' % href)
    2620. 

  2620.                 self.out.append(r'\goto{%s}[url(%s)]' % (href, href))
    2621. 

  2621.                 raise nodes.SkipNode
    2622. 

  2622.             self.out.append(r'\href{%s}{' % href)
    2623. 

  2623.             return
    2624. 

  2624.         # internal reference
    2625. 

  2625.         if 'refid' in node:
    2626. 

  2626.             href = node['refid']
    2627. 

  2627.         elif 'refname' in node:
    2628. 

  2628.             href = self.document.nameids[node['refname']]
    2629. 

  2629.         else:
    2630. 

  2630.             raise AssertionError('Unknown reference.')
    2631. 

  2631.         if not self.is_inline(node):
    2632. 

  2632.             self.out.append('\n')
    2633. 

  2633.         self.out.append('\\hyperref[%s]{' % href)
    2634. 

  2634.         if self._reference_label:
    2635. 

  2635.             self.out.append('\\%s{%s}}' %
    2636. 

  2636.                             (self._reference_label, href.replace('#', '')))
    2637. 

  2637.             raise nodes.SkipNode
    2638. 

  2638. 

  2639.     def depart_reference(self, node):
    2640. 

  2640.         self.out.append('}')
    2641. 

  2641.         if not self.is_inline(node):
    2642. 

  2642.             self.out.append('\n')
    2643. 

  2643. 

  2644.     def visit_revision(self, node):
    2645. 

  2645.         self.visit_docinfo_item(node, 'revision')
    2646. 

  2646. 

  2647.     def depart_revision(self, node):
    2648. 

  2648.         self.depart_docinfo_item(node)
    2649. 

  2649. 

  2650.     def visit_section(self, node):
    2651. 

  2651.         self.section_level += 1
    2652. 

  2652.         # Initialize counter for potential subsections:
    2653. 

  2653.         self._section_number.append(0)
    2654. 

  2654.         # Counter for this section's level (initialized by parent section):
    2655. 

  2655.         self._section_number[self.section_level - 1] += 1
    2656. 

  2656. 

  2657.     def depart_section(self, node):
    2658. 

  2658.         # Remove counter for potential subsections:
    2659. 

  2659.         self._section_number.pop()
    2660. 

  2660.         self.section_level -= 1
    2661. 

  2661. 

  2662.     def visit_sidebar(self, node):
    2663. 

  2663.         self.requirements['color'] = PreambleCmds.color
    2664. 

  2664.         self.fallbacks['sidebar'] = PreambleCmds.sidebar
    2665. 

  2665.         self.out.append('\n\\DUsidebar{\n')
    2666. 

  2666. 

  2667.     def depart_sidebar(self, node):
    2668. 

  2668.         self.out.append('}\n')
    2669. 

  2669. 

  2670.     attribution_formats = {'dash': (u'—', ''), # EM DASH
    2671. 

  2671.                            'parentheses': ('(', ')'),
    2672. 

  2672.                            'parens': ('(', ')'),
    2673. 

  2673.                            'none': ('', '')}
    2674. 

  2674. 

  2675.     def visit_attribution(self, node):
    2676. 

  2676.         prefix, suffix = self.attribution_formats[self.settings.attribution]
    2677. 

  2677.         self.out.append('\\nopagebreak\n\n\\raggedleft ')
    2678. 

  2678.         self.out.append(prefix)
    2679. 

  2679.         self.context.append(suffix)
    2680. 

  2680. 

  2681.     def depart_attribution(self, node):
    2682. 

  2682.         self.out.append(self.context.pop() + '\n')
    2683. 

  2683. 

  2684.     def visit_status(self, node):
    2685. 

  2685.         self.visit_docinfo_item(node, 'status')
    2686. 

  2686. 

  2687.     def depart_status(self, node):
    2688. 

  2688.         self.depart_docinfo_item(node)
    2689. 

  2689. 

  2690.     def visit_strong(self, node):
    2691. 

  2691.         self.out.append('{\\bf ')
    2692. 

  2692.         if node['classes']:
    2693. 

  2693.             self.visit_inline(node)
    2694. 

  2694. 

  2695.     def depart_strong(self, node):
    2696. 

  2696.         if node['classes']:
    2697. 

  2697.             self.depart_inline(node)
    2698. 

  2698.         self.out.append('}')
    2699. 

  2699. 

  2700.     def visit_substitution_definition(self, node):
    2701. 

  2701.         raise nodes.SkipNode
    2702. 

  2702. 

  2703.     def visit_substitution_reference(self, node):
    2704. 

  2704.         self.unimplemented_visit(node)
    2705. 

  2705. 

  2706.     def visit_subtitle(self, node):
    2707. 

  2707.         if isinstance(node.parent, nodes.document):
    2708. 

  2708.             self.push_output_collector(self.subtitle)
    2709. 

  2709.             self.subtitle_labels += self.ids_to_labels(node, set_anchor=False)
    2710. 

  2710.         # section subtitle: "starred" (no number, not in ToC)
    2711. 

  2711.         elif isinstance(node.parent, nodes.section):
    2712. 

  2712.             self.out.append(r'\%s*{' %
    2713. 

  2713.                              self.d_class.section(self.section_level + 1))
    2714. 

  2714.         else:
    2715. 

  2715.             self.fallbacks['subtitle'] = PreambleCmds.subtitle
    2716. 

  2716.             self.out.append('\n\\DUsubtitle[%s]{' % node.parent.tagname)
    2717. 

  2717. 

  2718.     def depart_subtitle(self, node):
    2719. 

  2719.         if isinstance(node.parent, nodes.document):
    2720. 

  2720.             self.pop_output_collector()
    2721. 

  2721.         else:
    2722. 

  2722.             self.out.append('}\n')
    2723. 

  2723. 

  2724.     def visit_system_message(self, node):
    2725. 

  2725.         self.requirements['color'] = PreambleCmds.color
    2726. 

  2726.         self.fallbacks['title'] = PreambleCmds.title
    2727. 

  2727.         node['classes'] = ['system-message']
    2728. 

  2728.         self.visit_admonition(node)
    2729. 

  2729.         self.out.append('\\DUtitle[system-message]{system-message}\n')
    2730. 

  2730.         self.append_hypertargets(node)
    2731. 

  2731.         try:
    2732. 

  2732.             line = ', line~%s' % node['line']
    2733. 

  2733.         except KeyError:
    2734. 

  2734.             line = ''
    2735. 

  2735.         self.out.append('\n\n{\color{red}%s/%s} in \\texttt{%s}%s\n' %
    2736. 

  2736.                          (node['type'], node['level'],
    2737. 

  2737.                           self.encode(node['source']), line))
    2738. 

  2738.         if len(node['backrefs']) == 1:
    2739. 

  2739.             self.out.append('\n\\hyperlink{%s}{' % node['backrefs'][0])
    2740. 

  2740.             self.context.append('}')
    2741. 

  2741.         else:
    2742. 

  2742.             backrefs = ['\\hyperlink{%s}{%d}' % (href, i+1)
    2743. 

  2743.                         for (i, href) in enumerate(node['backrefs'])]
    2744. 

  2744.             self.context.append('backrefs: ' + ' '.join(backrefs))
    2745. 

  2745. 

  2746.     def depart_system_message(self, node):
    2747. 

  2747.         self.out.append(self.context.pop())
    2748. 

  2748.         self.depart_admonition()
    2749. 

  2749. 

  2750.     def visit_table(self, node):
    2751. 

  2751.         self.requirements['table'] = PreambleCmds.table
    2752. 

  2752.         if self.active_table.is_open():
    2753. 

  2753.             self.table_stack.append(self.active_table)
    2754. 

  2754.             # nesting longtable does not work (e.g. 2007-04-18)
    2755. 

  2755.             self.active_table = Table(self,'tabular',self.settings.table_style)
    2756. 

  2756.         # A longtable moves before \paragraph and \subparagraph
    2757. 

  2757.         # section titles if it immediately follows them:
    2758. 

  2758.         if (self.active_table._latex_type == 'longtable' and
    2759. 

  2759.             isinstance(node.parent, nodes.section) and
    2760. 

  2760.             node.parent.index(node) == 1 and
    2761. 

  2761.             self.d_class.section(self.section_level).find('paragraph') != -1):
    2762. 

  2762.             self.out.append('\\leavevmode')
    2763. 

  2763.         self.active_table.open()
    2764. 

  2764.         for cls in node['classes']:
    2765. 

  2765.             self.active_table.set_table_style(cls)
    2766. 

  2766.         if self.active_table._table_style == 'booktabs':
    2767. 

  2767.             self.requirements['booktabs'] = r'\usepackage{booktabs}'
    2768. 

  2768.         self.push_output_collector([])
    2769. 

  2769. 

  2770.     def depart_table(self, node):
    2771. 

  2771.         # wrap content in the right environment:
    2772. 

  2772.         content = self.out
    2773. 

  2773.         self.pop_output_collector()
    2774. 

  2774.         self.out.append('\n' + self.active_table.get_opening())
    2775. 

  2775.         self.out += content
    2776. 

  2776.         self.out.append(self.active_table.get_closing() + '\n')
    2777. 

  2777.         self.active_table.close()
    2778. 

  2778.         if len(self.table_stack)>0:
    2779. 

  2779.             self.active_table = self.table_stack.pop()
    2780. 

  2780.         else:
    2781. 

  2781.             self.active_table.set_table_style(self.settings.table_style)
    2782. 

  2782.         # Insert hyperlabel after (long)table, as
    2783. 

  2783.         # other places (beginning, caption) result in LaTeX errors.
    2784. 

  2784.         if node.get('ids'):
    2785. 

  2785.             self.out += self.ids_to_labels(node, set_anchor=False) + ['\n']
    2786. 

  2786. 

  2787.     def visit_target(self, node):
    2788. 

  2788.         # Skip indirect targets:
    2789. 

  2789.         if ('refuri' in node       # external hyperlink
    2790. 

  2790.             or 'refid' in node     # resolved internal link
    2791. 

  2791.             or 'refname' in node): # unresolved internal link
    2792. 

  2792.             ## self.out.append('%% %s\n' % node)   # for debugging
    2793. 

  2793.             return
    2794. 

  2794.         self.out.append('%\n')
    2795. 

  2795.         # do we need an anchor (\phantomsection)?
    2796. 

  2796.         set_anchor = not(isinstance(node.parent, nodes.caption) or
    2797. 

  2797.                          isinstance(node.parent, nodes.title))
    2798. 

  2798.         # TODO: where else can/must we omit the \phantomsection?
    2799. 

  2799.         self.out += self.ids_to_labels(node, set_anchor)
    2800. 

  2800. 

  2801.     def depart_target(self, node):
    2802. 

  2802.         pass
    2803. 

  2803. 

  2804.     def visit_tbody(self, node):
    2805. 

  2805.         # BUG write preamble if not yet done (colspecs not [])
    2806. 

  2806.         # for tables without heads.
    2807. 

  2807.         if not self.active_table.get('preamble written'):
    2808. 

  2808.             self.visit_thead(None)
    2809. 

  2809.             self.depart_thead(None)
    2810. 

  2810. 

  2811.     def depart_tbody(self, node):
    2812. 

  2812.         pass
    2813. 

  2813. 

  2814.     def visit_term(self, node):
    2815. 

  2815.         """definition list term"""
    2816. 

  2816.         # Commands with optional args inside an optional arg must be put
    2817. 

  2817.         # in a group, e.g. ``\item[{\hyperref[label]{text}}]``.
    2818. 

  2818.         self.out.append('\\item[{')
    2819. 

  2819. 

  2820.     def depart_term(self, node):
    2821. 

  2821.         # \leavevmode results in a line break if the
    2822. 

  2822.         # term is followed by an item list.
    2823. 

  2823.         self.out.append('}] \leavevmode ')
    2824. 

  2824. 

  2825.     def visit_tgroup(self, node):
    2826. 

  2826.         #self.out.append(self.starttag(node, 'colgroup'))
    2827. 

  2827.         #self.context.append('</colgroup>\n')
    2828. 

  2828.         pass
    2829. 

  2829. 

  2830.     def depart_tgroup(self, node):
    2831. 

  2831.         pass
    2832. 

  2832. 

  2833.     _thead_depth = 0
    2834. 

  2834.     def thead_depth (self):
    2835. 

  2835.         return self._thead_depth
    2836. 

  2836. 

  2837.     def visit_thead(self, node):
    2838. 

  2838.         self._thead_depth += 1
    2839. 

  2839.         if 1 == self.thead_depth():
    2840. 

  2840.             self.out.append('{%s}\n' % self.active_table.get_colspecs())
    2841. 

  2841.             self.active_table.set('preamble written',1)
    2842. 

  2842.         self.out.append(self.active_table.get_caption())
    2843. 

  2843.         self.out.extend(self.active_table.visit_thead())
    2844. 

  2844. 

  2845.     def depart_thead(self, node):
    2846. 

  2846.         if node is not None:
    2847. 

  2847.             self.out.extend(self.active_table.depart_thead())
    2848. 

  2848.             if self.active_table.need_recurse():
    2849. 

  2849.                 node.walkabout(self)
    2850. 

  2850.         self._thead_depth -= 1
    2851. 

  2851. 

  2852.     def bookmark(self, node):
    2853. 

  2853.         """Return label and pdfbookmark string for titles."""
    2854. 

  2854.         result = ['']
    2855. 

  2855.         # if self.settings.sectnum_xform: # "starred" section cmd
    2856. 

  2856.             # add to the toc and pdfbookmarks
    2857. 

  2857.         #     section_name = self.d_class.section(max(self.section_level, 1))
    2858. 

  2858.         #     section_title = self.encode(node.astext())
    2859. 

  2859.         #     result.append(r'\addcontentsline{toc}{%s}{%s}' %
    2860. 

  2860.         #                   (section_name, section_title))
    2861. 

  2861.         # result += self.ids_to_labels(node.parent, set_anchor=False)
    2862. 

  2862.         return '%\n  '.join(result) + '%\n'
    2863. 

  2863. 

  2864.     def visit_title(self, node):
    2865. 

  2865.         """Append section and other titles."""
    2866. 

  2866. 

  2867.         def _section():
    2868. 

  2868.             self.out.append('\n\n')
    2869. 

  2869.             self.out.append('%' + '_' * 75)
    2870. 

  2870.             self.out.append('\n\n')
    2871. 

  2871.             #
    2872. 

  2872.             section_name = self.d_class.section(self.section_level+1)
    2873. 

  2873.             section_star = ''
    2874. 

  2874.             pdfanchor = ''
    2875. 

  2875.             # number sections?
    2876. 

  2876.             # if (self.settings.sectnum_xform # numbering by Docutils
    2877. 

  2877.             #     or (self.section_level > len(self.d_class.sections))):
    2878. 

  2878.             #     section_star = '*'
    2879. 

  2879.             #    pdfanchor = '\\phantomsection%\n  '
    2880. 

  2880.             self.out.append(r'\%s%s{%s' %
    2881. 

  2881.                             (section_name, section_star, pdfanchor))
    2882. 

  2882.             # System messages heading in red:
    2883. 

  2883.             if ('system-messages' in node.parent['classes']):
    2884. 

  2884.                 self.requirements['color'] = PreambleCmds.color
    2885. 

  2885.                 self.out.append('\color{red}')
    2886. 

  2886.             # label and ToC entry:
    2887. 

  2887.             self.context.append(self.bookmark(node) + '}\n')
    2888. 

  2888.             # MAYBE postfix paragraph and subparagraph with \leavemode to
    2889. 

  2889.             # ensure floats stay in the section and text starts on a new line.
    2890. 

  2890. 

  2891.         # Document title
    2892. 

  2892.         if node.parent.tagname == 'document':
    2893. 

  2893.             pass
    2894. 

  2894.             #_section()
    2895. 

  2895.         ##     self.push_output_collector(self.title)
    2896. 

  2896.         ##     self.context.append('')
    2897. 

  2897.         ##     self.pdfinfo.append('  pdftitle={%s},' %
    2898. 

  2898.         ##                         self.encode(node.astext()))
    2899. 

  2899.         # Topic titles (topic, admonition, sidebar)
    2900. 

  2900.         if (isinstance(node.parent, nodes.topic) or
    2901. 

  2901.             isinstance(node.parent, nodes.admonition) or
    2902. 

  2902.             isinstance(node.parent, nodes.sidebar)):
    2903. 

  2903.             self.fallbacks['title'] = PreambleCmds.title
    2904. 

  2904.             classes = ','.join(node.parent['classes'])
    2905. 

  2905.             if not classes:
    2906. 

  2906.                 classes = node.tagname
    2907. 

  2907.             self.out.append('\\DUtitle[%s]{' % classes)
    2908. 

  2908.             self.context.append('}\n')
    2909. 

  2909.         # Table caption
    2910. 

  2910.         elif isinstance(node.parent, nodes.table):
    2911. 

  2911.             self.push_output_collector(self.active_table.caption)
    2912. 

  2912.             self.context.append('')
    2913. 

  2913.         # Section title
    2914. 

  2914.         else:
    2915. 

  2915.             _section()
    2916. 

  2916. 

  2917. 

  2918.     def depart_title(self, node):
    2919. 

  2919.         self.out.append(self.context.pop())
    2920. 

  2920.         if isinstance(node.parent, nodes.table):
    2921. 

  2921.             #or node.parent.tagname == 'document':
    2922. 

  2922.             self.pop_output_collector()
    2923. 

  2923. 

  2924.     def minitoc(self, node, title, depth):
    2925. 

  2925.         """Generate a local table of contents with LaTeX package minitoc"""
    2926. 

  2926.         section_name = self.d_class.section(self.section_level)
    2927. 

  2927.         # name-prefix for current section level
    2928. 

  2928.         minitoc_names = {'part': 'part', 'chapter': 'mini'}
    2929. 

  2929.         if 'chapter' not in self.d_class.sections:
    2930. 

  2930.             minitoc_names['section'] = 'sect'
    2931. 

  2931.         try:
    2932. 

  2932.             minitoc_name = minitoc_names[section_name]
    2933. 

  2933.         except KeyError: # minitoc only supports part- and toplevel
    2934. 

  2934.             self.warn('Skipping local ToC at %s level.\n' % section_name +
    2935. 

  2935.                       '  Feature not supported with option "use-latex-toc"',
    2936. 

  2936.                       base_node=node)
    2937. 

  2937.             return
    2938. 

  2938.         # Requirements/Setup
    2939. 

  2939.         self.requirements['minitoc'] = PreambleCmds.minitoc
    2940. 

  2940.         self.requirements['minitoc-'+minitoc_name] = (r'\do%stoc' %
    2941. 

  2941.                                                       minitoc_name)
    2942. 

  2942.         # depth: (Docutils defaults to unlimited depth)
    2943. 

  2943.         maxdepth = len(self.d_class.sections)
    2944. 

  2944.         self.requirements['minitoc-%s-depth' % minitoc_name] = (
    2945. 

  2945.             r'\mtcsetdepth{%stoc}{%d}' % (minitoc_name, maxdepth))
    2946. 

  2946.         # Process 'depth' argument (!Docutils stores a relative depth while
    2947. 

  2947.         # minitoc  expects an absolute depth!):
    2948. 

  2948.         offset = {'sect': 1, 'mini': 0, 'part': 0}
    2949. 

  2949.         if 'chapter' in self.d_class.sections:
    2950. 

  2950.             offset['part'] = -1
    2951. 

  2951.         if depth:
    2952. 

  2952.             self.out.append('\\setcounter{%stocdepth}{%d}' %
    2953. 

  2953.                              (minitoc_name, depth + offset[minitoc_name]))
    2954. 

  2954.         # title:
    2955. 

  2955.         self.out.append('\\mtcsettitle{%stoc}{%s}\n' % (minitoc_name, title))
    2956. 

  2956.         # the toc-generating command:
    2957. 

  2957.         self.out.append('\\%stoc\n' % minitoc_name)
    2958. 

  2958. 

  2959.     def visit_topic(self, node):
    2960. 

  2960.         # Topic nodes can be generic topic, abstract, dedication, or ToC.
    2961. 

  2961.         # table of contents:
    2962. 

  2962.         if 'contents' in node['classes']:
    2963. 

  2963.             self.out.append('\n')
    2964. 

  2964.             self.out += self.ids_to_labels(node)
    2965. 

  2965.             # add contents to PDF bookmarks sidebar
    2966. 

  2966.             if isinstance(node.next_node(), nodes.title):
    2967. 

  2967.                 self.out.append('\n\\pdfbookmark[%d]{%s}{%s}\n' %
    2968. 

  2968.                                 (self.section_level+1,
    2969. 

  2969.                                  node.next_node().astext(),
    2970. 

  2970.                                  node.get('ids', ['contents'])[0]
    2971. 

  2971.                                 ))
    2972. 

  2972.             if self.use_latex_toc:
    2973. 

  2973.                 title = ''
    2974. 

  2974.                 if isinstance(node.next_node(), nodes.title):
    2975. 

  2975.                     title = self.encode(node.pop(0).astext())
    2976. 

  2976.                 depth = node.get('depth', 0)
    2977. 

  2977.                 if 'local' in node['classes']:
    2978. 

  2978.                     self.minitoc(node, title, depth)
    2979. 

  2979.                     self.context.append('')
    2980. 

  2980.                     return
    2981. 

  2981.                 if depth:
    2982. 

  2982.                     self.out.append('\\setcounter{tocdepth}{%d}\n' % depth)
    2983. 

  2983.                 if title != 'Contents':
    2984. 

  2984.                     self.out.append('\\renewcommand{\\contentsname}{%s}\n' %
    2985. 

  2985.                                     title)
    2986. 

  2986.                 self.out.append('\\tableofcontents\n\n')
    2987. 

  2987.                 self.has_latex_toc = True
    2988. 

  2988.             else: # Docutils generated contents list
    2989. 

  2989.                 # set flag for visit_bullet_list() and visit_title()
    2990. 

  2990.                 self.is_toc_list = True
    2991. 

  2991.             self.context.append('')
    2992. 

  2992.         elif ('abstract' in node['classes'] and
    2993. 

  2993.               self.settings.use_latex_abstract):
    2994. 

  2994.             self.push_output_collector(self.abstract)
    2995. 

  2995.             self.out.append('\\begin{abstract}')
    2996. 

  2996.             self.context.append('\\end{abstract}\n')
    2997. 

  2997.             if isinstance(node.next_node(), nodes.title):
    2998. 

  2998.                 node.pop(0) # LaTeX provides its own title
    2999. 

  2999.         else:
    3000. 

  3000.             self.fallbacks['topic'] = PreambleCmds.topic
    3001. 

  3001.             # special topics:
    3002. 

  3002.             if 'abstract' in node['classes']:
    3003. 

  3003.                 self.fallbacks['abstract'] = PreambleCmds.abstract
    3004. 

  3004.                 self.push_output_collector(self.abstract)
    3005. 

  3005.             if 'dedication' in node['classes']:
    3006. 

  3006.                 self.fallbacks['dedication'] = PreambleCmds.dedication
    3007. 

  3007.                 self.push_output_collector(self.dedication)
    3008. 

  3008.             self.out.append('\n\\DUtopic[%s]{\n' % ','.join(node['classes']))
    3009. 

  3009.             self.context.append('}\n')
    3010. 

  3010. 

  3011.     def depart_topic(self, node):
    3012. 

  3012.         self.out.append(self.context.pop())
    3013. 

  3013.         self.is_toc_list = False
    3014. 

  3014.         if ('abstract' in node['classes'] or
    3015. 

  3015.             'dedication' in node['classes']):
    3016. 

  3016.             self.pop_output_collector()
    3017. 

  3017. 

  3018.     def visit_rubric(self, node):
    3019. 

  3019.         self.fallbacks['rubric'] = PreambleCmds.rubric
    3020. 

  3020.         self.out.append('\n\\DUrubric{')
    3021. 

  3021.         self.context.append('}\n')
    3022. 

  3022. 

  3023.     def depart_rubric(self, node):
    3024. 

  3024.         self.out.append(self.context.pop())
    3025. 

  3025. 

  3026.     def visit_transition(self, node):
    3027. 

  3027.         self.fallbacks['transition'] = PreambleCmds.transition
    3028. 

  3028.         self.out.append('\n\n')
    3029. 

  3029.         self.out.append('%' + '_' * 75 + '\n')
    3030. 

  3030.         self.out.append(r'\DUtransition')
    3031. 

  3031.         self.out.append('\n\n')
    3032. 

  3032. 

  3033.     def depart_transition(self, node):
    3034. 

  3034.         pass
    3035. 

  3035. 

  3036.     def visit_version(self, node):
    3037. 

  3037.         self.visit_docinfo_item(node, 'version')
    3038. 

  3038. 

  3039.     def depart_version(self, node):
    3040. 

  3040.         self.depart_docinfo_item(node)
    3041. 

  3041. 

  3042.     def unimplemented_visit(self, node):
    3043. 

  3043.         raise NotImplementedError('visiting unimplemented node type: %s' %
    3044. 

  3044.                                   node.__class__.__name__)
    3045. 

  3045. 

  3046. #    def unknown_visit(self, node):
    3047. 

  3047. #    def default_visit(self, node):
    3048. 

  3048. 

  3049. # vim: set ts=4 et ai :
    3050. 

  3050.