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
81 from parser_tools import find_token, find_end_of_inset
82 from unicode_symbols import unicode_reps
84 # This will accept either a list of lines or a single line.
85 # It is bad practice to pass something with embedded newlines,
86 # though we will handle that.
87 def add_to_preamble(document, text):
88 " Add text to the preamble if it is not already there. "
90 if not type(text) is list:
91 # split on \n just in case
92 # it'll give us the one element list we want
93 # if there's no \n, too
94 text = text.split('\n')
97 prelen = len(document.preamble)
99 i = find_token(document.preamble, text[0], i)
102 # we need a perfect match
105 if i >= prelen or line != document.preamble[i]:
112 document.preamble.extend(["% Added by lyx2lyx"])
113 document.preamble.extend(text)
116 # Note that text can be either a list of lines or a single line.
117 # It should really be a list.
118 def insert_to_preamble(document, text, index = 0):
119 """ Insert text to the preamble at a given line"""
121 if not type(text) is list:
122 # split on \n just in case
123 # it'll give us the one element list we want
124 # if there's no \n, too
125 text = text.split('\n')
127 text.insert(0, "% Added by lyx2lyx")
128 document.preamble[index:index] = text
131 # A dictionary of Unicode->LICR mappings for use in a Unicode string's translate() method
132 # Created from the reversed list to keep the first of alternative definitions.
133 licr_table = dict((ord(ch), cmd) for cmd, ch in unicode_reps[::-1])
135 def put_cmd_in_ert(cmd):
137 Return ERT inset wrapping `cmd` as a list of strings.
139 `cmd` can be a string or list of lines. Non-ASCII characters are converted
140 to the respective LICR macros if defined in unicodesymbols.
142 ret = ["\\begin_inset ERT", "status collapsed", "", "\\begin_layout Plain Layout", ""]
143 # It will be faster to work with a single string internally.
144 if isinstance(cmd, list):
145 cmd = u"\n".join(cmd)
147 cmd = u"%s" % cmd # ensure it is an unicode instance
148 cmd = cmd.translate(licr_table)
149 cmd = cmd.replace("\\", "\\backslash\n")
150 ret += cmd.splitlines()
151 ret += ["\\end_layout", "", "\\end_inset"]
155 def get_ert(lines, i, verbatim = False):
156 'Convert an ERT inset into LaTeX.'
157 if not lines[i].startswith("\\begin_inset ERT"):
159 j = find_end_of_inset(lines, i)
162 while i < j and not lines[i].startswith("status"):
168 if lines[i] == "\\begin_layout Plain Layout":
173 while i + 1 < j and lines[i+1] == "":
175 elif lines[i] == "\\end_layout":
176 while i + 1 < j and lines[i+1] == "":
178 elif lines[i] == "\\backslash":
180 ret = ret + "\n" + lines[i] + "\n"
189 def lyx2latex(document, lines):
190 'Convert some LyX stuff into corresponding LaTeX stuff, as best we can.'
197 for curline in range(len(lines)):
198 line = lines[curline]
199 if line.startswith("\\begin_inset Note Note"):
200 # We want to skip LyX notes, so remember where the inset ends
201 note_end = find_end_of_inset(lines, curline + 1)
203 elif note_end >= curline:
206 elif line.startswith("\\begin_inset ERT"):
207 # We don't want to replace things inside ERT, so figure out
208 # where the end of the inset is.
209 ert_end = find_end_of_inset(lines, curline + 1)
211 elif line.startswith("\\begin_inset Formula"):
213 elif line.startswith("\\begin_inset Quotes"):
214 # For now, we do a very basic reversion. Someone who understands
215 # quotes is welcome to fix it up.
216 qtype = line[20:].strip()
230 elif line.startswith("\\begin_inset Newline newline"):
232 elif line.startswith("\\noindent"):
233 line = "\\noindent " # we need the space behind the command
234 elif line.startswith("\\begin_inset space"):
235 line = line[18:].strip()
236 if line.startswith("\\hspace"):
237 # Account for both \hspace and \hspace*
240 elif line == "\\space{}":
242 elif line == "\\thinspace{}":
245 # The LyX length is in line[8:], after the \length keyword
246 length = latex_length(line[8:])[1]
247 line = hspace + "{" + length + "}"
249 elif line.isspace() or \
250 line.startswith("\\begin_layout") or \
251 line.startswith("\\end_layout") or \
252 line.startswith("\\begin_inset") or \
253 line.startswith("\\end_inset") or \
254 line.startswith("\\lang") or \
255 line.strip() == "status collapsed" or \
256 line.strip() == "status open":
260 # this needs to be added to the preamble because of cases like
261 # \textmu, \textbackslash, etc.
262 add_to_preamble(document, ['% added by lyx2lyx for converted index entries',
263 '\\@ifundefined{textmu}',
264 ' {\\usepackage{textcomp}}{}'])
265 # a lossless reversion is not possible
266 # try at least to handle some common insets and settings
267 if ert_end >= curline:
268 line = line.replace(r'\backslash', '\\')
270 # No need to add "{}" after single-nonletter macros
271 line = line.replace('&', '\\&')
272 line = line.replace('#', '\\#')
273 line = line.replace('^', '\\textasciicircum{}')
274 line = line.replace('%', '\\%')
275 line = line.replace('_', '\\_')
276 line = line.replace('$', '\\$')
278 # Do the LyX text --> LaTeX conversion
279 for rep in unicode_reps:
280 line = line.replace(rep[1], rep[0])
281 line = line.replace(r'\backslash', r'\textbackslash{}')
282 line = line.replace(r'\series bold', r'\bfseries{}').replace(r'\series default', r'\mdseries{}')
283 line = line.replace(r'\shape italic', r'\itshape{}').replace(r'\shape smallcaps', r'\scshape{}')
284 line = line.replace(r'\shape slanted', r'\slshape{}').replace(r'\shape default', r'\upshape{}')
285 line = line.replace(r'\emph on', r'\em{}').replace(r'\emph default', r'\em{}')
286 line = line.replace(r'\noun on', r'\scshape{}').replace(r'\noun default', r'\upshape{}')
287 line = line.replace(r'\bar under', r'\underbar{').replace(r'\bar default', r'}')
288 line = line.replace(r'\family sans', r'\sffamily{}').replace(r'\family default', r'\normalfont{}')
289 line = line.replace(r'\family typewriter', r'\ttfamily{}').replace(r'\family roman', r'\rmfamily{}')
290 line = line.replace(r'\InsetSpace ', r'').replace(r'\SpecialChar ', r'')
295 def lyx2verbatim(document, lines):
296 'Convert some LyX stuff into corresponding verbatim stuff, as best we can.'
298 content = lyx2latex(document, lines)
299 content = re.sub(r'\\(?!backslash)', r'\n\\backslash\n', content)
304 def latex_length(slen):
306 Convert lengths to their LaTeX representation. Returns (bool, length),
307 where the bool tells us if it was a percentage, and the length is the
308 LaTeX representation.
312 # the slen has the form
313 # ValueUnit+ValueUnit-ValueUnit or
314 # ValueUnit+-ValueUnit
315 # the + and - (glue lengths) are optional
316 # the + always precedes the -
318 # Convert relative lengths to LaTeX units
319 units = {"col%": "\\columnwidth",
320 "text%": "\\textwidth",
321 "page%": "\\paperwidth",
322 "line%": "\\linewidth",
323 "theight%": "\\textheight",
324 "pheight%": "\\paperheight",
325 "baselineskip%": "\\baselineskip"
327 for unit in list(units.keys()):
332 minus = slen.rfind("-", 1, i)
333 plus = slen.rfind("+", 0, i)
334 latex_unit = units[unit]
335 if plus == -1 and minus == -1:
337 value = str(float(value)/100)
338 end = slen[i + len(unit):]
339 slen = value + latex_unit + end
341 value = slen[plus + 1:i]
342 value = str(float(value)/100)
343 begin = slen[:plus + 1]
344 end = slen[i+len(unit):]
345 slen = begin + value + latex_unit + end
347 value = slen[minus + 1:i]
348 value = str(float(value)/100)
349 begin = slen[:minus + 1]
350 slen = begin + value + latex_unit
352 # replace + and -, but only if the - is not the first character
353 slen = slen[0] + slen[1:].replace("+", " plus ").replace("-", " minus ")
354 # handle the case where "+-1mm" was used, because LaTeX only understands
355 # "plus 1mm minus 1mm"
356 if slen.find("plus minus"):
357 lastvaluepos = slen.rfind(" ")
358 lastvalue = slen[lastvaluepos:]
359 slen = slen.replace(" ", lastvalue + " ")
360 return (percent, slen)
363 def length_in_bp(length):
364 " Convert a length in LyX format to its value in bp units "
366 em_width = 10.0 / 72.27 # assume 10pt font size
367 text_width = 8.27 / 1.7 # assume A4 with default margins
368 # scale factors are taken from Length::inInch()
369 scales = {"bp" : 1.0,
370 "cc" : (72.0 / (72.27 / (12.0 * 0.376 * 2.845))),
371 "cm" : (72.0 / 2.54),
372 "dd" : (72.0 / (72.27 / (0.376 * 2.845))),
373 "em" : (72.0 * em_width),
374 "ex" : (72.0 * em_width * 0.4305),
376 "mm" : (72.0 / 25.4),
377 "mu" : (72.0 * em_width / 18.0),
378 "pc" : (72.0 / (72.27 / 12.0)),
379 "pt" : (72.0 / (72.27)),
380 "sp" : (72.0 / (72.27 * 65536.0)),
381 "text%" : (72.0 * text_width / 100.0),
382 "col%" : (72.0 * text_width / 100.0), # assume 1 column
383 "page%" : (72.0 * text_width * 1.7 / 100.0),
384 "line%" : (72.0 * text_width / 100.0),
385 "theight%" : (72.0 * text_width * 1.787 / 100.0),
386 "pheight%" : (72.0 * text_width * 2.2 / 100.0)}
388 rx = re.compile(r'^\s*([^a-zA-Z%]+)([a-zA-Z%]+)\s*$')
391 document.warning("Invalid length value: " + length + ".")
395 if not unit in scales.keys():
396 document.warning("Unknown length unit: " + unit + ".")
398 return "%g" % (float(value) * scales[unit])
401 def revert_flex_inset(lines, name, LaTeXname):
402 " Convert flex insets to TeX code "
405 i = find_token(lines, '\\begin_inset Flex ' + name, i)
408 z = find_end_of_inset(lines, i)
410 document.warning("Can't find end of Flex " + name + " inset.")
413 # remove the \end_inset
414 lines[z - 2:z + 1] = put_cmd_in_ert("}")
415 # we need to reset character layouts if necessary
416 j = find_token(lines, '\\emph on', i, z)
417 k = find_token(lines, '\\noun on', i, z)
418 l = find_token(lines, '\\series', i, z)
419 m = find_token(lines, '\\family', i, z)
420 n = find_token(lines, '\\shape', i, z)
421 o = find_token(lines, '\\color', i, z)
422 p = find_token(lines, '\\size', i, z)
423 q = find_token(lines, '\\bar under', i, z)
424 r = find_token(lines, '\\uuline on', i, z)
425 s = find_token(lines, '\\uwave on', i, z)
426 t = find_token(lines, '\\strikeout on', i, z)
428 lines.insert(z - 2, "\\emph default")
430 lines.insert(z - 2, "\\noun default")
432 lines.insert(z - 2, "\\series default")
434 lines.insert(z - 2, "\\family default")
436 lines.insert(z - 2, "\\shape default")
438 lines.insert(z - 2, "\\color inherit")
440 lines.insert(z - 2, "\\size default")
442 lines.insert(z - 2, "\\bar default")
444 lines.insert(z - 2, "\\uuline default")
446 lines.insert(z - 2, "\\uwave default")
448 lines.insert(z - 2, "\\strikeout default")
449 lines[i:i + 4] = put_cmd_in_ert(LaTeXname + "{")
453 def revert_font_attrs(lines, name, LaTeXname):
454 " Reverts font changes to TeX code "
458 i = find_token(lines, name + ' on', i)
461 j = find_token(lines, name + ' default', i)
462 k = find_token(lines, name + ' on', i + 1)
463 # if there is no default set, the style ends with the layout
464 # assure hereby that we found the correct layout end
465 if j != -1 and (j < k or k == -1):
466 lines[j:j + 1] = put_cmd_in_ert("}")
468 j = find_token(lines, '\\end_layout', i)
469 lines[j:j] = put_cmd_in_ert("}")
470 lines[i:i + 1] = put_cmd_in_ert(LaTeXname + "{")
475 def revert_layout_command(lines, name, LaTeXname):
476 " Reverts a command from a layout to TeX code "
479 i = find_token(lines, '\\begin_layout ' + name, i)
483 # find the next layout
486 j = find_token(lines, '\\begin_layout', j)
488 # if nothing was found it was the last layout of the document
490 lines[l - 4:l - 4] = put_cmd_in_ert("}")
492 # exclude plain layout because this can be TeX code or another inset
493 elif lines[j] != '\\begin_layout Plain Layout':
494 lines[j - 2:j - 2] = put_cmd_in_ert("}")
498 lines[i] = '\\begin_layout Standard'
499 lines[i + 1:i + 1] = put_cmd_in_ert(LaTeXname + "{")
504 " Converts an RRGGBB-type hexadecimal string to a float in [0.0,1.0] "
511 return str(val / 256.0)
515 "'true' goes to True, case-insensitively, and we strip whitespace."
516 s = s.strip().lower()
520 def convert_info_insets(document, type, func):
521 "Convert info insets matching type using func."
523 type_re = re.compile(r'^type\s+"(%s)"$' % type)
524 arg_re = re.compile(r'^arg\s+"(.*)"$')
526 i = find_token(document.body, "\\begin_inset Info", i)
529 t = type_re.match(document.body[i + 1])
531 arg = arg_re.match(document.body[i + 2])
533 new_arg = func(arg.group(1))
534 document.body[i + 2] = 'arg "%s"' % new_arg