1 # This file is part of lyx2lyx
2 # -*- coding: utf-8 -*-
3 # Copyright (C) 2011 The LyX team
5 # This program is free software; you can redistribute it and/or
6 # modify it under the terms of the GNU General Public License
7 # as published by the Free Software Foundation; either version 2
8 # of the License, or (at your option) any later version.
10 # This program is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 # GNU General Public License for more details.
15 # You should have received a copy of the GNU General Public License
16 # along with this program; if not, write to the Free Software
17 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 This module offers several free functions to help with lyx2lyx'ing.
21 More documentaton is below, but here is a quick guide to what
22 they do. Optional arguments are marked by brackets.
24 add_to_preamble(document, text):
25 Here, text can be either a single line or a list of lines. It
26 is bad practice to pass something with embedded newlines, but
27 we will handle that properly.
28 The routine checks to see whether the provided material is
29 already in the preamble. If not, it adds it.
30 Prepends a comment "% Added by lyx2lyx" to text.
32 insert_to_preamble(document, text[, index]):
33 Here, text can be either a single line or a list of lines. It
34 is bad practice to pass something with embedded newlines, but
35 we will handle that properly.
36 The routine inserts text at document.preamble[index], where by
37 default index is 0, so the material is inserted at the beginning.
38 Prepends a comment "% Added by lyx2lyx" to text.
41 Here cmd should be a list of strings (lines), which we want to
42 wrap in ERT. Returns a list of strings so wrapped.
43 A call to this routine will often go something like this:
44 i = find_token('\\begin_inset FunkyInset', ...)
45 j = find_end_of_inset(document.body, i)
46 content = lyx2latex(document[i:j + 1])
47 ert = put_cmd_in_ert(content)
48 document.body[i:j+1] = ert
50 get_ert(lines, i[, verbatim]):
51 Here, lines is a list of lines of LyX material containing an ERT inset,
52 whose content we want to convert to LaTeX. The ERT starts at index i.
53 If the optional (by default: False) bool verbatim is True, the content
54 of the ERT is returned verbatim, that is in LyX syntax (not LaTeX syntax)
55 for the use in verbatim insets.
57 lyx2latex(document, lines):
58 Here, lines is a list of lines of LyX material we want to convert
59 to LaTeX. We do the best we can and return a string containing
60 the translated material.
62 lyx2verbatim(document, lines):
63 Here, lines is a list of lines of LyX material we want to convert
64 to verbatim material (used in ERT an the like). We do the best we
65 can and return a string containing the translated material.
68 Convert lengths (in LyX form) to their LaTeX representation. Returns
69 (bool, length), where the bool tells us if it was a percentage, and
70 the length is the LaTeX representation.
72 convert_info_insets(document, type, func):
73 Applies func to the argument of all info insets matching certain types
74 type : the type to match. This can be a regular expression.
75 func : function from string to string to apply to the "arg" field of
78 is_document_option(document, option):
79 Find if _option_ is a document option (\\options in the header).
81 insert_document_option(document, option):
82 Insert _option_ as a document option.
84 remove_document_option(document, option):
85 Remove _option_ as a document option.
87 revert_language(document, lyxname, babelname, polyglossianame):
88 Reverts native language support to ERT
89 If babelname or polyglossianame is empty, it is assumed
90 this language package is not supported for the given language.
94 from parser_tools import find_token, find_end_of_inset, get_containing_layout, get_value, get_bool_value
95 from unicode_symbols import unicode_reps
97 # This will accept either a list of lines or a single line.
98 # It is bad practice to pass something with embedded newlines,
99 # though we will handle that.
100 def add_to_preamble(document, text):
101 " Add text to the preamble if it is not already there. "
103 if not type(text) is list:
104 # split on \n just in case
105 # it'll give us the one element list we want
106 # if there's no \n, too
107 text = text.split('\n')
110 prelen = len(document.preamble)
112 i = find_token(document.preamble, text[0], i)
115 # we need a perfect match
118 if i >= prelen or line != document.preamble[i]:
125 document.preamble.extend(["% Added by lyx2lyx"])
126 document.preamble.extend(text)
129 # Note that text can be either a list of lines or a single line.
130 # It should really be a list.
131 def insert_to_preamble(document, text, index = 0):
132 """ Insert text to the preamble at a given line"""
134 if not type(text) is list:
135 # split on \n just in case
136 # it'll give us the one element list we want
137 # if there's no \n, too
138 text = text.split('\n')
140 text.insert(0, "% Added by lyx2lyx")
141 document.preamble[index:index] = text
144 # A dictionary of Unicode->LICR mappings for use in a Unicode string's translate() method
145 # Created from the reversed list to keep the first of alternative definitions.
146 licr_table = dict((ord(ch), cmd) for cmd, ch in unicode_reps[::-1])
148 def put_cmd_in_ert(cmd):
150 Return ERT inset wrapping `cmd` as a list of strings.
152 `cmd` can be a string or list of lines. Non-ASCII characters are converted
153 to the respective LICR macros if defined in unicodesymbols.
155 ret = ["\\begin_inset ERT", "status collapsed", "", "\\begin_layout Plain Layout", ""]
156 # It will be faster to work with a single string internally.
157 if isinstance(cmd, list):
158 cmd = u"\n".join(cmd)
160 cmd = u"%s" % cmd # ensure it is an unicode instance
161 cmd = cmd.translate(licr_table)
162 cmd = cmd.replace("\\", "\n\\backslash\n")
163 ret += cmd.splitlines()
164 ret += ["\\end_layout", "", "\\end_inset"]
168 def get_ert(lines, i, verbatim = False):
169 'Convert an ERT inset into LaTeX.'
170 if not lines[i].startswith("\\begin_inset ERT"):
172 j = find_end_of_inset(lines, i)
175 while i < j and not lines[i].startswith("status"):
181 if lines[i] == "\\begin_layout Plain Layout":
186 while i + 1 < j and lines[i+1] == "":
188 elif lines[i] == "\\end_layout":
189 while i + 1 < j and lines[i+1] == "":
191 elif lines[i] == "\\backslash":
193 ret = ret + "\n" + lines[i] + "\n"
202 def lyx2latex(document, lines):
203 'Convert some LyX stuff into corresponding LaTeX stuff, as best we can.'
210 for curline in range(len(lines)):
211 line = lines[curline]
212 if line.startswith("\\begin_inset Note Note"):
213 # We want to skip LyX notes, so remember where the inset ends
214 note_end = find_end_of_inset(lines, curline + 1)
216 elif note_end >= curline:
219 elif line.startswith("\\begin_inset ERT"):
220 # We don't want to replace things inside ERT, so figure out
221 # where the end of the inset is.
222 ert_end = find_end_of_inset(lines, curline + 1)
224 elif line.startswith("\\begin_inset Formula"):
226 elif line.startswith("\\begin_inset Quotes"):
227 # For now, we do a very basic reversion. Someone who understands
228 # quotes is welcome to fix it up.
229 qtype = line[20:].strip()
243 elif line.startswith("\\begin_inset Newline newline"):
245 elif line.startswith("\\noindent"):
246 line = "\\noindent " # we need the space behind the command
247 elif line.startswith("\\begin_inset space"):
248 line = line[18:].strip()
249 if line.startswith("\\hspace"):
250 # Account for both \hspace and \hspace*
253 elif line == "\\space{}":
255 elif line == "\\thinspace{}":
258 # The LyX length is in line[8:], after the \length keyword
259 length = latex_length(line[8:])[1]
260 line = hspace + "{" + length + "}"
262 elif line.isspace() or \
263 line.startswith("\\begin_layout") or \
264 line.startswith("\\end_layout") or \
265 line.startswith("\\begin_inset") or \
266 line.startswith("\\end_inset") or \
267 line.startswith("\\lang") or \
268 line.strip() == "status collapsed" or \
269 line.strip() == "status open":
273 # this needs to be added to the preamble because of cases like
274 # \textmu, \textbackslash, etc.
275 add_to_preamble(document, ['% added by lyx2lyx for converted index entries',
276 '\\@ifundefined{textmu}',
277 ' {\\usepackage{textcomp}}{}'])
278 # a lossless reversion is not possible
279 # try at least to handle some common insets and settings
280 if ert_end >= curline:
281 line = line.replace(r'\backslash', '\\')
283 # No need to add "{}" after single-nonletter macros
284 line = line.replace('&', '\\&')
285 line = line.replace('#', '\\#')
286 line = line.replace('^', '\\textasciicircum{}')
287 line = line.replace('%', '\\%')
288 line = line.replace('_', '\\_')
289 line = line.replace('$', '\\$')
291 # Do the LyX text --> LaTeX conversion
292 for rep in unicode_reps:
293 line = line.replace(rep[1], rep[0])
294 line = line.replace(r'\backslash', r'\textbackslash{}')
295 line = line.replace(r'\series bold', r'\bfseries{}').replace(r'\series default', r'\mdseries{}')
296 line = line.replace(r'\shape italic', r'\itshape{}').replace(r'\shape smallcaps', r'\scshape{}')
297 line = line.replace(r'\shape slanted', r'\slshape{}').replace(r'\shape default', r'\upshape{}')
298 line = line.replace(r'\emph on', r'\em{}').replace(r'\emph default', r'\em{}')
299 line = line.replace(r'\noun on', r'\scshape{}').replace(r'\noun default', r'\upshape{}')
300 line = line.replace(r'\bar under', r'\underbar{').replace(r'\bar default', r'}')
301 line = line.replace(r'\family sans', r'\sffamily{}').replace(r'\family default', r'\normalfont{}')
302 line = line.replace(r'\family typewriter', r'\ttfamily{}').replace(r'\family roman', r'\rmfamily{}')
303 line = line.replace(r'\InsetSpace ', r'').replace(r'\SpecialChar ', r'')
308 def lyx2verbatim(document, lines):
309 'Convert some LyX stuff into corresponding verbatim stuff, as best we can.'
311 content = lyx2latex(document, lines)
312 content = re.sub(r'\\(?!backslash)', r'\n\\backslash\n', content)
317 def latex_length(slen):
319 Convert lengths to their LaTeX representation. Returns (bool, length),
320 where the bool tells us if it was a percentage, and the length is the
321 LaTeX representation.
325 # the slen has the form
326 # ValueUnit+ValueUnit-ValueUnit or
327 # ValueUnit+-ValueUnit
328 # the + and - (glue lengths) are optional
329 # the + always precedes the -
331 # Convert relative lengths to LaTeX units
332 units = {"col%": "\\columnwidth",
333 "text%": "\\textwidth",
334 "page%": "\\paperwidth",
335 "line%": "\\linewidth",
336 "theight%": "\\textheight",
337 "pheight%": "\\paperheight",
338 "baselineskip%": "\\baselineskip"
340 for unit in list(units.keys()):
345 minus = slen.rfind("-", 1, i)
346 plus = slen.rfind("+", 0, i)
347 latex_unit = units[unit]
348 if plus == -1 and minus == -1:
350 value = str(float(value)/100)
351 end = slen[i + len(unit):]
352 slen = value + latex_unit + end
354 value = slen[plus + 1:i]
355 value = str(float(value)/100)
356 begin = slen[:plus + 1]
357 end = slen[i+len(unit):]
358 slen = begin + value + latex_unit + end
360 value = slen[minus + 1:i]
361 value = str(float(value)/100)
362 begin = slen[:minus + 1]
363 slen = begin + value + latex_unit
365 # replace + and -, but only if the - is not the first character
366 slen = slen[0] + slen[1:].replace("+", " plus ").replace("-", " minus ")
367 # handle the case where "+-1mm" was used, because LaTeX only understands
368 # "plus 1mm minus 1mm"
369 if slen.find("plus minus"):
370 lastvaluepos = slen.rfind(" ")
371 lastvalue = slen[lastvaluepos:]
372 slen = slen.replace(" ", lastvalue + " ")
373 return (percent, slen)
376 def length_in_bp(length):
377 " Convert a length in LyX format to its value in bp units "
379 em_width = 10.0 / 72.27 # assume 10pt font size
380 text_width = 8.27 / 1.7 # assume A4 with default margins
381 # scale factors are taken from Length::inInch()
382 scales = {"bp" : 1.0,
383 "cc" : (72.0 / (72.27 / (12.0 * 0.376 * 2.845))),
384 "cm" : (72.0 / 2.54),
385 "dd" : (72.0 / (72.27 / (0.376 * 2.845))),
386 "em" : (72.0 * em_width),
387 "ex" : (72.0 * em_width * 0.4305),
389 "mm" : (72.0 / 25.4),
390 "mu" : (72.0 * em_width / 18.0),
391 "pc" : (72.0 / (72.27 / 12.0)),
392 "pt" : (72.0 / (72.27)),
393 "sp" : (72.0 / (72.27 * 65536.0)),
394 "text%" : (72.0 * text_width / 100.0),
395 "col%" : (72.0 * text_width / 100.0), # assume 1 column
396 "page%" : (72.0 * text_width * 1.7 / 100.0),
397 "line%" : (72.0 * text_width / 100.0),
398 "theight%" : (72.0 * text_width * 1.787 / 100.0),
399 "pheight%" : (72.0 * text_width * 2.2 / 100.0)}
401 rx = re.compile(r'^\s*([^a-zA-Z%]+)([a-zA-Z%]+)\s*$')
404 document.warning("Invalid length value: " + length + ".")
408 if not unit in scales.keys():
409 document.warning("Unknown length unit: " + unit + ".")
411 return "%g" % (float(value) * scales[unit])
414 def revert_flex_inset(lines, name, LaTeXname):
415 " Convert flex insets to TeX code "
418 i = find_token(lines, '\\begin_inset Flex ' + name, i)
421 z = find_end_of_inset(lines, i)
423 document.warning("Can't find end of Flex " + name + " inset.")
426 # remove the \end_inset
427 lines[z - 2:z + 1] = put_cmd_in_ert("}")
428 # we need to reset character layouts if necessary
429 j = find_token(lines, '\\emph on', i, z)
430 k = find_token(lines, '\\noun on', i, z)
431 l = find_token(lines, '\\series', i, z)
432 m = find_token(lines, '\\family', i, z)
433 n = find_token(lines, '\\shape', i, z)
434 o = find_token(lines, '\\color', i, z)
435 p = find_token(lines, '\\size', i, z)
436 q = find_token(lines, '\\bar under', i, z)
437 r = find_token(lines, '\\uuline on', i, z)
438 s = find_token(lines, '\\uwave on', i, z)
439 t = find_token(lines, '\\strikeout on', i, z)
441 lines.insert(z - 2, "\\emph default")
443 lines.insert(z - 2, "\\noun default")
445 lines.insert(z - 2, "\\series default")
447 lines.insert(z - 2, "\\family default")
449 lines.insert(z - 2, "\\shape default")
451 lines.insert(z - 2, "\\color inherit")
453 lines.insert(z - 2, "\\size default")
455 lines.insert(z - 2, "\\bar default")
457 lines.insert(z - 2, "\\uuline default")
459 lines.insert(z - 2, "\\uwave default")
461 lines.insert(z - 2, "\\strikeout default")
462 lines[i:i + 4] = put_cmd_in_ert(LaTeXname + "{")
466 def revert_font_attrs(lines, name, LaTeXname):
467 " Reverts font changes to TeX code "
471 i = find_token(lines, name + ' on', i)
474 j = find_token(lines, name + ' default', i)
475 k = find_token(lines, name + ' on', i + 1)
476 # if there is no default set, the style ends with the layout
477 # assure hereby that we found the correct layout end
478 if j != -1 and (j < k or k == -1):
479 lines[j:j + 1] = put_cmd_in_ert("}")
481 j = find_token(lines, '\\end_layout', i)
482 lines[j:j] = put_cmd_in_ert("}")
483 lines[i:i + 1] = put_cmd_in_ert(LaTeXname + "{")
487 # now delete all remaining lines that manipulate this attribute
490 i = find_token(lines, name, i)
498 def revert_layout_command(lines, name, LaTeXname):
499 " Reverts a command from a layout to TeX code "
502 i = find_token(lines, '\\begin_layout ' + name, i)
506 # find the next layout
509 j = find_token(lines, '\\begin_layout', j)
511 # if nothing was found it was the last layout of the document
513 lines[l - 4:l - 4] = put_cmd_in_ert("}")
515 # exclude plain layout because this can be TeX code or another inset
516 elif lines[j] != '\\begin_layout Plain Layout':
517 lines[j - 2:j - 2] = put_cmd_in_ert("}")
521 lines[i] = '\\begin_layout Standard'
522 lines[i + 1:i + 1] = put_cmd_in_ert(LaTeXname + "{")
527 " Converts an RRGGBB-type hexadecimal string to a float in [0.0,1.0] "
534 return str(val / 256.0)
538 "'true' goes to True, case-insensitively, and we strip whitespace."
539 s = s.strip().lower()
543 def convert_info_insets(document, type, func):
544 "Convert info insets matching type using func."
546 type_re = re.compile(r'^type\s+"(%s)"$' % type)
547 arg_re = re.compile(r'^arg\s+"(.*)"$')
549 i = find_token(document.body, "\\begin_inset Info", i)
552 t = type_re.match(document.body[i + 1])
554 arg = arg_re.match(document.body[i + 2])
556 new_arg = func(arg.group(1))
557 document.body[i + 2] = 'arg "%s"' % new_arg
561 def insert_document_option(document, option):
562 "Insert _option_ as a document option."
564 # Find \options in the header
565 options_line = find_token(document.header, "\\options", 0)
567 # if the options does not exists add it after the textclass
568 if options_line == -1:
569 textclass_line = find_token(document.header, "\\textclass", 0)
570 document.header.insert(textclass_line +1,
571 r"\options %s" % option)
574 # add it to the end of the options
575 document.header[options_line] += ",%s" % option
578 def remove_document_option(document, option):
579 """ Remove _option_ as a document option.
581 It is assumed that option belongs to the \options.
582 That can be done running is_document_option(document, option)."""
584 options_line = find_token(document.header, "\\options", 0)
585 option_pos = document.header[options_line].find(option)
587 # Remove option from \options
588 comma_before_pos = document.header[options_line].rfind(',', 0, option_pos)
589 comma_after_pos = document.header[options_line].find(',', option_pos)
591 # if there are no commas then it is the single option
592 # and the options line should be removed since it will be empty
593 if comma_before_pos == comma_after_pos == -1:
594 del document.header[options_line]
598 options = document.header[options_line]
599 if comma_after_pos == -1:
600 document.header[options_line] = options[:comma_before_pos].rsplit()
603 document.header[options_line] = options[comma_before_pos: comma_after_pos]
606 def is_document_option(document, option):
607 "Find if _option_ is a document option"
609 # Find \options in the header
610 options_line = find_token(document.header, "\\options", 0)
612 # \options is not present in the header
613 if options_line == -1:
616 option_pos = document.header[options_line].find(option)
617 # option is not present in the \options
624 def revert_language(document, lyxname, babelname, polyglossianame):
625 " Revert native language support "
627 # Are we using polyglossia?
628 use_polyglossia = False
629 if get_bool_value(document.header, "\\use_non_tex_fonts"):
630 i = find_token(document.header, "\\language_package")
632 document.warning("Malformed document! Missing \\language_package")
634 pack = get_value(document.header, "\\language_package", i)
635 if pack == "default" or pack == "auto":
636 use_polyglossia = True
638 # Do we use this language with polyglossia?
639 with_polyglossia = use_polyglossia and polyglossianame != ""
640 # Do we use this language with babel?
641 with_babel = with_polyglossia == False and babelname != ""
643 # Are we dealing with a primary or secondary language?
647 orig_doc_language = document.language
648 # Main language first
649 if document.language == lyxname:
651 document.language = "english"
652 i = find_token(document.header, "\\language %s" % lyxname, 0)
654 document.header[i] = "\\language english"
655 j = find_token(document.header, "\\language_package default", 0)
657 document.header[j] = "\\language_package default"
659 add_to_preamble(document, ["\\AtBeginDocument{\setotherlanguage{%s}}" % polyglossianame])
660 document.body[2 : 2] = ["\\begin_layout Standard",
661 "\\begin_inset ERT", "status open", "",
662 "\\begin_layout Plain Layout", "", "",
664 "resetdefaultlanguage{%s}" % polyglossianame,
665 "\\end_layout", "", "\\end_inset", "", "",
668 # Now secondary languages
671 i = find_token(document.body, '\\lang', i)
674 if document.body[i].startswith('\\lang %s' % lyxname):
676 endlang = get_containing_layout(document.body, i)[2]
677 langswitch = find_token(document.body, '\\lang', i + 1, endlang)
678 startlayout = "\\begin_layout Standard"
679 endlayout = "\\end_layout"
685 add_to_preamble(document, ["\\AtBeginDocument{\setotherlanguage{%s}}" % polyglossianame])
686 document.body[endlang : endlang] = [startlayout,
687 "\\begin_inset ERT", "status open", "",
688 "\\begin_layout Plain Layout", "", "",
690 "end{%s}" % polyglossianame,
691 "\\end_layout", "", "\\end_inset", "", "",
694 document.body[endlang : endlang] = [startlayout,
695 "\\begin_inset ERT", "status open", "",
696 "\\begin_layout Plain Layout", "", "",
698 "end{otherlanguage}",
699 "\\end_layout", "", "\\end_inset", "", "",
703 document.body[i : i] = ["\\begin_inset ERT", "status open", "",
704 "\\begin_layout Plain Layout", "", "",
706 "begin{%s}" % polyglossianame,
707 "\\end_layout", "", "\\end_inset", "", "",
710 document.body[i : i] = ["\\begin_inset ERT", "status open", "",
711 "\\begin_layout Plain Layout", "", "",
713 "begin{otherlanguage}{%s}" % babelname,
714 "\\end_layout", "", "\\end_inset", "", "",
716 elif primary and document.body[i].startswith('\\lang english'):
717 # Since we switched the main language manually, English parts need to be marked
718 endlang = get_containing_layout(document.body, i)[2]
719 langswitch = find_token(document.body, '\\lang', i + 1, endlang)
720 startlayout = "\\begin_layout Standard"
721 endlayout = "\\end_layout"
727 parent = get_containing_layout(document.body, i)
728 document.body[endlang : endlang] = [startlayout,
729 "\\begin_inset ERT", "status open", "",
730 "\\begin_layout Plain Layout", "", "",
733 "\\end_layout", "", "\\end_inset", "", "",
736 parent = get_containing_layout(document.body, i)
737 document.body[endlang : endlang] = [startlayout,
738 "\\begin_inset ERT", "status open", "",
739 "\\begin_layout Plain Layout", "", "",
741 "end{otherlanguage}",
742 "\\end_layout", "", "\\end_inset", "", "",
746 document.body[i : i] = ["\\begin_inset ERT", "status open", "",
747 "\\begin_layout Plain Layout", "", "",
750 "\\end_layout", "", "\\end_inset", "", "",
753 document.body[i : i] = ["\\begin_inset ERT", "status open", "",
754 "\\begin_layout Plain Layout", "", "",
756 "begin{otherlanguage}{english}",
757 "\\end_layout", "", "\\end_inset", "", "",
762 # With babel, we need to add the language options
763 if with_babel and (primary or secondary):
764 insert_document_option(document, babelname)
765 if secondary and document.body[10] != "selectlanguage{%s}" % orig_doc_language:
766 # Since the user options are always placed after the babel options,
767 # we need to reset the main language
768 document.body[2 : 2] = ["\\begin_layout Standard",
769 "\\begin_inset ERT", "status open", "",
770 "\\begin_layout Plain Layout", "", "",
772 "selectlanguage{%s}" % orig_doc_language,
773 "\\end_layout", "", "\\end_inset", "", "",