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, is_open=False, as_paragraph=False):
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,
154 `is_open` is a boolean setting the inset status to "open",
155 `as_paragraph` wraps the ERT inset in a Standard paragraph.
158 status = {False:"collapsed", True:"open"}
159 ert_inset = ["\\begin_inset ERT", "status %s"%status[is_open], "",
160 "\\begin_layout Plain Layout", "",
161 # content here ([5:5])
162 "\\end_layout", "", "\\end_inset"]
164 paragraph = ["\\begin_layout Standard",
165 # content here ([1:1])
166 "", "", "\\end_layout", ""]
167 # ensure cmd is an unicode instance and make it "LyX safe".
168 if isinstance(cmd, list):
169 cmd = u"\n".join(cmd)
170 elif sys.version_info[0] == 2 and isinstance(cmd, str):
171 cmd = cmd.decode('utf8')
172 cmd = cmd.translate(licr_table)
173 cmd = cmd.replace("\\", "\n\\backslash\n")
175 ert_inset[5:5] = cmd.splitlines()
178 paragraph[1:1] = ert_inset
182 def get_ert(lines, i, verbatim = False):
183 'Convert an ERT inset into LaTeX.'
184 if not lines[i].startswith("\\begin_inset ERT"):
186 j = find_end_of_inset(lines, i)
189 while i < j and not lines[i].startswith("status"):
195 if lines[i] == "\\begin_layout Plain Layout":
200 while i + 1 < j and lines[i+1] == "":
202 elif lines[i] == "\\end_layout":
203 while i + 1 < j and lines[i+1] == "":
205 elif lines[i] == "\\backslash":
207 ret = ret + "\n" + lines[i] + "\n"
216 def lyx2latex(document, lines):
217 'Convert some LyX stuff into corresponding LaTeX stuff, as best we can.'
224 for curline in range(len(lines)):
225 line = lines[curline]
226 if line.startswith("\\begin_inset Note Note"):
227 # We want to skip LyX notes, so remember where the inset ends
228 note_end = find_end_of_inset(lines, curline + 1)
230 elif note_end >= curline:
233 elif line.startswith("\\begin_inset ERT"):
234 # We don't want to replace things inside ERT, so figure out
235 # where the end of the inset is.
236 ert_end = find_end_of_inset(lines, curline + 1)
238 elif line.startswith("\\begin_inset Formula"):
240 elif line.startswith("\\begin_inset Quotes"):
241 # For now, we do a very basic reversion. Someone who understands
242 # quotes is welcome to fix it up.
243 qtype = line[20:].strip()
257 elif line.startswith("\\begin_inset Newline newline"):
259 elif line.startswith("\\noindent"):
260 line = "\\noindent " # we need the space behind the command
261 elif line.startswith("\\begin_inset space"):
262 line = line[18:].strip()
263 if line.startswith("\\hspace"):
264 # Account for both \hspace and \hspace*
267 elif line == "\\space{}":
269 elif line == "\\thinspace{}":
272 # The LyX length is in line[8:], after the \length keyword
273 length = latex_length(line[8:])[1]
274 line = hspace + "{" + length + "}"
276 elif line.isspace() or \
277 line.startswith("\\begin_layout") or \
278 line.startswith("\\end_layout") or \
279 line.startswith("\\begin_inset") or \
280 line.startswith("\\end_inset") or \
281 line.startswith("\\lang") or \
282 line.strip() == "status collapsed" or \
283 line.strip() == "status open":
287 # this needs to be added to the preamble because of cases like
288 # \textmu, \textbackslash, etc.
289 add_to_preamble(document, ['% added by lyx2lyx for converted index entries',
290 '\\@ifundefined{textmu}',
291 ' {\\usepackage{textcomp}}{}'])
292 # a lossless reversion is not possible
293 # try at least to handle some common insets and settings
294 if ert_end >= curline:
295 line = line.replace(r'\backslash', '\\')
297 # No need to add "{}" after single-nonletter macros
298 line = line.replace('&', '\\&')
299 line = line.replace('#', '\\#')
300 line = line.replace('^', '\\textasciicircum{}')
301 line = line.replace('%', '\\%')
302 line = line.replace('_', '\\_')
303 line = line.replace('$', '\\$')
305 # Do the LyX text --> LaTeX conversion
306 for rep in unicode_reps:
307 line = line.replace(rep[1], rep[0])
308 line = line.replace(r'\backslash', r'\textbackslash{}')
309 line = line.replace(r'\series bold', r'\bfseries{}').replace(r'\series default', r'\mdseries{}')
310 line = line.replace(r'\shape italic', r'\itshape{}').replace(r'\shape smallcaps', r'\scshape{}')
311 line = line.replace(r'\shape slanted', r'\slshape{}').replace(r'\shape default', r'\upshape{}')
312 line = line.replace(r'\emph on', r'\em{}').replace(r'\emph default', r'\em{}')
313 line = line.replace(r'\noun on', r'\scshape{}').replace(r'\noun default', r'\upshape{}')
314 line = line.replace(r'\bar under', r'\underbar{').replace(r'\bar default', r'}')
315 line = line.replace(r'\family sans', r'\sffamily{}').replace(r'\family default', r'\normalfont{}')
316 line = line.replace(r'\family typewriter', r'\ttfamily{}').replace(r'\family roman', r'\rmfamily{}')
317 line = line.replace(r'\InsetSpace ', r'').replace(r'\SpecialChar ', r'')
322 def lyx2verbatim(document, lines):
323 'Convert some LyX stuff into corresponding verbatim stuff, as best we can.'
325 content = lyx2latex(document, lines)
326 content = re.sub(r'\\(?!backslash)', r'\n\\backslash\n', content)
331 def latex_length(slen):
333 Convert lengths to their LaTeX representation. Returns (bool, length),
334 where the bool tells us if it was a percentage, and the length is the
335 LaTeX representation.
339 # the slen has the form
340 # ValueUnit+ValueUnit-ValueUnit or
341 # ValueUnit+-ValueUnit
342 # the + and - (glue lengths) are optional
343 # the + always precedes the -
345 # Convert relative lengths to LaTeX units
346 units = {"col%": "\\columnwidth",
347 "text%": "\\textwidth",
348 "page%": "\\paperwidth",
349 "line%": "\\linewidth",
350 "theight%": "\\textheight",
351 "pheight%": "\\paperheight",
352 "baselineskip%": "\\baselineskip"
354 for unit in list(units.keys()):
359 minus = slen.rfind("-", 1, i)
360 plus = slen.rfind("+", 0, i)
361 latex_unit = units[unit]
362 if plus == -1 and minus == -1:
364 value = str(float(value)/100)
365 end = slen[i + len(unit):]
366 slen = value + latex_unit + end
368 value = slen[plus + 1:i]
369 value = str(float(value)/100)
370 begin = slen[:plus + 1]
371 end = slen[i+len(unit):]
372 slen = begin + value + latex_unit + end
374 value = slen[minus + 1:i]
375 value = str(float(value)/100)
376 begin = slen[:minus + 1]
377 slen = begin + value + latex_unit
379 # replace + and -, but only if the - is not the first character
380 slen = slen[0] + slen[1:].replace("+", " plus ").replace("-", " minus ")
381 # handle the case where "+-1mm" was used, because LaTeX only understands
382 # "plus 1mm minus 1mm"
383 if slen.find("plus minus"):
384 lastvaluepos = slen.rfind(" ")
385 lastvalue = slen[lastvaluepos:]
386 slen = slen.replace(" ", lastvalue + " ")
387 return (percent, slen)
390 def length_in_bp(length):
391 " Convert a length in LyX format to its value in bp units "
393 em_width = 10.0 / 72.27 # assume 10pt font size
394 text_width = 8.27 / 1.7 # assume A4 with default margins
395 # scale factors are taken from Length::inInch()
396 scales = {"bp" : 1.0,
397 "cc" : (72.0 / (72.27 / (12.0 * 0.376 * 2.845))),
398 "cm" : (72.0 / 2.54),
399 "dd" : (72.0 / (72.27 / (0.376 * 2.845))),
400 "em" : (72.0 * em_width),
401 "ex" : (72.0 * em_width * 0.4305),
403 "mm" : (72.0 / 25.4),
404 "mu" : (72.0 * em_width / 18.0),
405 "pc" : (72.0 / (72.27 / 12.0)),
406 "pt" : (72.0 / (72.27)),
407 "sp" : (72.0 / (72.27 * 65536.0)),
408 "text%" : (72.0 * text_width / 100.0),
409 "col%" : (72.0 * text_width / 100.0), # assume 1 column
410 "page%" : (72.0 * text_width * 1.7 / 100.0),
411 "line%" : (72.0 * text_width / 100.0),
412 "theight%" : (72.0 * text_width * 1.787 / 100.0),
413 "pheight%" : (72.0 * text_width * 2.2 / 100.0)}
415 rx = re.compile(r'^\s*([^a-zA-Z%]+)([a-zA-Z%]+)\s*$')
418 document.warning("Invalid length value: " + length + ".")
422 if not unit in scales.keys():
423 document.warning("Unknown length unit: " + unit + ".")
425 return "%g" % (float(value) * scales[unit])
428 def revert_flex_inset(lines, name, LaTeXname):
429 " Convert flex insets to TeX code "
432 i = find_token(lines, '\\begin_inset Flex ' + name, i)
435 z = find_end_of_inset(lines, i)
437 document.warning("Can't find end of Flex " + name + " inset.")
440 # remove the \end_inset
441 lines[z - 2:z + 1] = put_cmd_in_ert("}")
442 # we need to reset character layouts if necessary
443 j = find_token(lines, '\\emph on', i, z)
444 k = find_token(lines, '\\noun on', i, z)
445 l = find_token(lines, '\\series', i, z)
446 m = find_token(lines, '\\family', i, z)
447 n = find_token(lines, '\\shape', i, z)
448 o = find_token(lines, '\\color', i, z)
449 p = find_token(lines, '\\size', i, z)
450 q = find_token(lines, '\\bar under', i, z)
451 r = find_token(lines, '\\uuline on', i, z)
452 s = find_token(lines, '\\uwave on', i, z)
453 t = find_token(lines, '\\strikeout on', i, z)
455 lines.insert(z - 2, "\\emph default")
457 lines.insert(z - 2, "\\noun default")
459 lines.insert(z - 2, "\\series default")
461 lines.insert(z - 2, "\\family default")
463 lines.insert(z - 2, "\\shape default")
465 lines.insert(z - 2, "\\color inherit")
467 lines.insert(z - 2, "\\size default")
469 lines.insert(z - 2, "\\bar default")
471 lines.insert(z - 2, "\\uuline default")
473 lines.insert(z - 2, "\\uwave default")
475 lines.insert(z - 2, "\\strikeout default")
476 lines[i:i + 4] = put_cmd_in_ert(LaTeXname + "{")
480 def revert_font_attrs(lines, name, LaTeXname):
481 " Reverts font changes to TeX code "
485 i = find_token(lines, name + ' on', i)
488 j = find_token(lines, name + ' default', i)
489 k = find_token(lines, name + ' on', i + 1)
490 # if there is no default set, the style ends with the layout
491 # assure hereby that we found the correct layout end
492 if j != -1 and (j < k or k == -1):
493 lines[j:j + 1] = put_cmd_in_ert("}")
495 j = find_token(lines, '\\end_layout', i)
496 lines[j:j] = put_cmd_in_ert("}")
497 lines[i:i + 1] = put_cmd_in_ert(LaTeXname + "{")
501 # now delete all remaining lines that manipulate this attribute
504 i = find_token(lines, name, i)
512 def revert_layout_command(lines, name, LaTeXname):
513 " Reverts a command from a layout to TeX code "
516 i = find_token(lines, '\\begin_layout ' + name, i)
520 # find the next layout
523 j = find_token(lines, '\\begin_layout', j)
525 # if nothing was found it was the last layout of the document
527 lines[l - 4:l - 4] = put_cmd_in_ert("}")
529 # exclude plain layout because this can be TeX code or another inset
530 elif lines[j] != '\\begin_layout Plain Layout':
531 lines[j - 2:j - 2] = put_cmd_in_ert("}")
535 lines[i] = '\\begin_layout Standard'
536 lines[i + 1:i + 1] = put_cmd_in_ert(LaTeXname + "{")
541 " Converts an RRGGBB-type hexadecimal string to a float in [0.0,1.0] "
548 return str(val / 256.0)
552 "'true' goes to True, case-insensitively, and we strip whitespace."
553 s = s.strip().lower()
557 def convert_info_insets(document, type, func):
558 "Convert info insets matching type using func."
560 type_re = re.compile(r'^type\s+"(%s)"$' % type)
561 arg_re = re.compile(r'^arg\s+"(.*)"$')
563 i = find_token(document.body, "\\begin_inset Info", i)
566 t = type_re.match(document.body[i + 1])
568 arg = arg_re.match(document.body[i + 2])
570 new_arg = func(arg.group(1))
571 document.body[i + 2] = 'arg "%s"' % new_arg
575 def insert_document_option(document, option):
576 "Insert _option_ as a document option."
578 # Find \options in the header
579 options_line = find_token(document.header, "\\options", 0)
581 # if the options does not exists add it after the textclass
582 if options_line == -1:
583 textclass_line = find_token(document.header, "\\textclass", 0)
584 document.header.insert(textclass_line +1,
585 r"\options %s" % option)
588 # add it to the end of the options
589 document.header[options_line] += ",%s" % option
592 def remove_document_option(document, option):
593 """ Remove _option_ as a document option.
595 It is assumed that option belongs to the \options.
596 That can be done running is_document_option(document, option)."""
598 options_line = find_token(document.header, "\\options", 0)
599 option_pos = document.header[options_line].find(option)
601 # Remove option from \options
602 comma_before_pos = document.header[options_line].rfind(',', 0, option_pos)
603 comma_after_pos = document.header[options_line].find(',', option_pos)
605 # if there are no commas then it is the single option
606 # and the options line should be removed since it will be empty
607 if comma_before_pos == comma_after_pos == -1:
608 del document.header[options_line]
612 options = document.header[options_line]
613 if comma_after_pos == -1:
614 document.header[options_line] = options[:comma_before_pos].rsplit()
617 document.header[options_line] = options[comma_before_pos: comma_after_pos]
620 def is_document_option(document, option):
621 "Find if _option_ is a document option"
623 # Find \options in the header
624 options_line = find_token(document.header, "\\options", 0)
626 # \options is not present in the header
627 if options_line == -1:
630 option_pos = document.header[options_line].find(option)
631 # option is not present in the \options
637 def revert_language(document, lyxname, babelname="", polyglossianame=""):
638 " Revert native language support "
640 # Does the document use polyglossia?
641 use_polyglossia = False
642 if get_bool_value(document.header, "\\use_non_tex_fonts"):
643 i = find_token(document.header, "\\language_package")
645 document.warning("Malformed document! Missing \\language_package")
647 pack = get_value(document.header, "\\language_package", i)
648 if pack == "default" or pack == "auto":
649 use_polyglossia = True
651 # Do we use this language with polyglossia?
652 with_polyglossia = use_polyglossia and polyglossianame != ""
653 # Do we use this language with babel?
654 with_babel = with_polyglossia == False and babelname != ""
656 # Are we dealing with a primary or secondary language?
660 orig_doc_language = document.language
661 # Main language first
662 if document.language == lyxname:
664 document.language = "english"
665 i = find_token(document.header, "\\language %s" % lyxname, 0)
667 document.header[i] = "\\language english"
669 add_to_preamble(document, ["\\AtBeginDocument{\setotherlanguage{%s}}" % polyglossianame])
670 document.body[2 : 2] = put_cmd_in_ert("\\resetdefaultlanguage{%s}"%polyglossianame,
671 is_open=True, as_paragraph=True)
673 # Now secondary languages
676 i = find_token(document.body, '\\lang', i)
679 if document.body[i].startswith('\\lang %s' % lyxname):
681 endlang = get_containing_layout(document.body, i)[2]
682 langswitch = find_token(document.body, '\\lang', i + 1, endlang)
688 add_to_preamble(document, ["\\AtBeginDocument{\setotherlanguage{%s}}" % polyglossianame])
689 document.body[endlang:endlang] = put_cmd_in_ert("\\end{%s}"%polyglossianame,
691 as_paragraph=as_paragraph)
693 document.body[endlang:endlang] = put_cmd_in_ert("\\end{otherlanguage}",
695 as_paragraph=as_paragraph)
698 document.body[i:i] = put_cmd_in_ert("\\begin{%s}"%polyglossianame,
701 document.body[i:i] = put_cmd_in_ert("\\begin{otherlanguage}{%s}" % babelname,
703 elif primary and document.body[i].startswith('\\lang english'):
704 # Since we switched the main language manually, English parts need to be marked
705 endlang = get_containing_layout(document.body, i)[2]
706 langswitch = find_token(document.body, '\\lang', i + 1, endlang)
712 parent = get_containing_layout(document.body, i)
713 document.body[endlang:endlang] = put_cmd_in_ert("\\end{english}",
715 as_paragraph=as_paragraph)
717 parent = get_containing_layout(document.body, i)
718 document.body[endlang:endlang] = put_cmd_in_ert("\\end{otherlanguage}",
720 as_paragraph=as_paragraph)
723 document.body[i:i] = put_cmd_in_ert("\\begin{english}",
726 document.body[i:i] = put_cmd_in_ert("\\begin{otherlanguage}{english}",
731 # With babel, we need to add the language options
732 if with_babel and (primary or secondary):
733 insert_document_option(document, babelname)
734 if secondary and document.body[10] != "selectlanguage{%s}" % orig_doc_language:
735 # Since the user options are always placed after the babel options,
736 # we need to reset the main language
737 document.body[2:2] = put_cmd_in_ert("\\selectlanguage{%s}" % orig_doc_language,
738 is_open=True, as_paragraph=True)