# -*- coding: utf-8 -*-
# This file is part of lyx2lyx
-# -*- coding: utf-8 -*-
# Copyright (C) 2011 The LyX team
#
# This program is free software; you can redistribute it and/or
from parser_tools import count_pars_in_inset, del_token, find_token, find_token_exact, \
find_token_backwards, find_end_of, find_end_of_inset, find_end_of_layout, \
find_end_of_sequence, find_re, get_option_value, get_containing_layout, \
- get_value, get_quoted_value, set_option_value
+ get_containing_inset, get_value, get_quoted_value, set_option_value
#from parser_tools import find_token, find_end_of, find_tokens, \
#find_end_of_inset, find_end_of_layout, \
Reverts an InsetArgument to TeX-code
usage:
revert_Argument_to_TeX_brace(document, LineOfBegin, LineOfEnd, StartArgument, EndArgument, isEnvironment, isOpt)
- LineOfBegin is the line of the \begin_layout or \begin_inset statement
+ LineOfBegin is the line of the \\begin_layout or \\begin_inset statement
LineOfEnd is the line of the \end_layout or \end_inset statement, if "0" is given, the end of the file is used instead
StartArgument is the number of the first argument that needs to be converted
EndArgument is the number of the last argument that needs to be converted or the last defined one
- { and } surround a mandatory argument of an environment
usage:
convert_TeX_brace_to_Argument(document, LineOfBeginLayout/Inset, StartArgument, EndArgument, isInset, isEnvironment, isOpt)
- LineOfBeginLayout/Inset is the line of the \begin_layout or \begin_inset statement
+ LineOfBeginLayout/Inset is the line of the \\begin_layout or \\begin_inset statement
StartArgument is the number of the first ERT that needs to be converted
EndArgument is the number of the last ERT that needs to be converted
isInset must be true, if braces inside an InsetLayout needs to be converted
isEnvironment must be true, if the layout is for a LaTeX environment
isOpt must be true, if the argument is an optional one
-
+
Todo: this routine can currently handle only one mandatory argument of environments
'''
n += 1
endn = end
loop += 1
- else:
+ else:
# no brace pair found
# now check the case that we have "}" + "{" in two ERTs
if opt:
else:
beginBrace = find_token(document.body, "{", endBrace, end_layout)
# assure that the ERTs are consecutive (11 or 12 depending if there is a space between the ERTs or not)
- if beginBrace == endBrace + 11 or beginBrace == endBrace + 12:
+ if beginBrance != -1 and (beginBrace == endBrace + 11 or beginBrace == endBrace + 12):
end = find_token(document.body, "\\end_inset", beginBrace)
document.body[lineERT : end + 1] = ["\\end_layout", "", "\\end_inset"]
if loop == 1:
else:
lineERT += 1
if environment == True:
+ # FIXME This version of the routine does not check for and pass over
+ # arguments before n. So it attempts to process the argument in the
+ # document, no matter what has been specified.
+ #
+ # The other branch does do that, but probably that code would be better
+ # in a single location: Skip all those arguments, then process the ones
+ # we want.
end_ERT = find_end_of_inset(document.body, lineERT)
if end_ERT == -1:
document.warning("Can't find end of ERT!!")
else:
opening = find_token(document.body, "{", lineERT, end_ERT)
if opening != -1:
- document.body[lineERT : end_ERT + 1] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
- n += 1
lineERT2 = find_token(document.body, "\\begin_inset ERT", end_ERT, end_layout)
- if lineERT2 != -1:
+ if lineERT2 == -1:
+ # argument in a single ERT
+ # strip off the opening bracket
+ document.body[opening] = document.body[opening][1:]
+ ertcontlastline = end_ERT - 3
+ if (opt and document.body[ertcontlastline].endswith("]")) or document.body[ertcontlastline].endswith("}"):
+ # strip off the closing bracket
+ document.body[ertcontlastline] = document.body[ertcontlastline][:-1]
+ end2 = find_token(document.body, "\\end_inset", ertcontlastline)
+ document.body[lineERT : lineERT + 1] = ["\\begin_inset Argument " + str(n)]
+ else:
end_ERT2 = find_end_of_inset(document.body, lineERT2)
if end_ERT2 == -1:
document.warning("Can't find end of second ERT!!")
if closing != -1: # assure that the "}" is in this ERT
end2 = find_token(document.body, "\\end_inset", closing)
document.body[lineERT2 : end2 + 1] = ["\\end_layout", "", "\\end_inset"]
+ document.body[lineERT : end_ERT + 1] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
+ n += 1
+ else:
+ document.warning("Unable to process argument!")
+ n += 1
###############################################################################
if i == -1:
return
val = get_value(document.header, "\\inputencoding", i)
- if val in jap_enc_dict.keys():
+ if val in list(jap_enc_dict.keys()):
document.header[i] = "\\inputencoding %s" % jap_enc_dict[val]
if i == -1:
return
val = get_value(document.header, "\\inputencoding", i)
- if val in jap_enc_dict.keys():
+ if val in list(jap_enc_dict.keys()):
document.header[i] = "\\inputencoding %s" % jap_enc_dict[val]
def revert_australian(document):
- "Set English language variants Australian and Newzealand to English"
+ "Set English language variants Australian and Newzealand to English"
- if document.language == "australian" or document.language == "newzealand":
+ if document.language == "australian" or document.language == "newzealand":
document.language = "english"
- i = find_token(document.header, "\\language", 0)
- if i != -1:
- document.header[i] = "\\language english"
- j = 0
- while True:
- j = find_token(document.body, "\\lang australian", j)
+ i = find_token(document.header, "\\language", 0)
+ if i != -1:
+ document.header[i] = "\\language english"
+ j = 0
+ while True:
+ j = find_token(document.body, "\\lang australian", j)
if j == -1:
j = find_token(document.body, "\\lang newzealand", 0)
if j == -1:
else:
document.body[j] = document.body[j].replace("\\lang newzealand", "\\lang english")
else:
- document.body[j] = document.body[j].replace("\\lang australian", "\\lang english")
+ document.body[j] = document.body[j].replace("\\lang australian", "\\lang english")
j += 1
if get_option_value(document.body[begin_row], 'endlastfoot') == 'true':
document.body[begin_row] = set_option_value(document.body[begin_row], 'endlastfoot', 'false')
begin_row = end_row
- # since there could be a tabular inside this one, we
+ # since there could be a tabular inside this one, we
# cannot jump to end.
begin_table += 1
revert_use_package(document, "cancel", cancel_commands, False)
-def revert_verbatim(document):
- " Revert verbatim einvironments completely to TeX-code. "
+def revert_verbatim(document, starred = False):
+ " Revert verbatim environments completely to TeX-code. "
i = 0
consecutive = False
- subst_end = ['\end_layout', '', '\\begin_layout Plain Layout',
- '\end_layout', '',
+
+ layout_name = "Verbatim"
+ latex_name = "verbatim"
+ if starred:
+ layout_name = "Verbatim*"
+ latex_name = "verbatim*"
+
+ subst_end = ['\\end_layout', '', '\\begin_layout Plain Layout',
+ '\\end_layout', '',
'\\begin_layout Plain Layout', '', '',
'\\backslash', '',
- 'end{verbatim}',
+ 'end{%s}' % (latex_name),
'\\end_layout', '', '\\end_inset',
'', '', '\\end_layout']
subst_begin = ['\\begin_layout Standard', '\\noindent',
'\\begin_inset ERT', 'status open', '',
'\\begin_layout Plain Layout', '', '', '\\backslash',
- 'begin{verbatim}',
+ 'begin{%s}' % (latex_name),
'\\end_layout', '', '\\begin_layout Plain Layout', '']
- while 1:
- i = find_token(document.body, "\\begin_layout Verbatim", i)
+ while True:
+ i = find_token(document.body, "\\begin_layout %s" % (layout_name), i)
if i == -1:
return
j = find_end_of_layout(document.body, i)
if j == -1:
- document.warning("Malformed LyX document: Can't find end of Verbatim layout")
+ document.warning("Malformed LyX document: Can't find end of %s layout" \
+ % (layout_name))
i += 1
continue
# delete all line breaks insets (there are no other insets)
l = i
- while 1:
+ while True:
n = find_token(document.body, "\\begin_inset Newline newline", l, j)
if n == -1:
n = find_token(document.body, "\\begin_inset Newline linebreak", l, j)
break
m = find_end_of_inset(document.body, n)
del(document.body[m:m+1])
- document.body[n:n+1] = ['\end_layout', '', '\\begin_layout Plain Layout']
+ document.body[n:n+1] = ['\\end_layout', '', '\\begin_layout Plain Layout']
l += 1
# we deleted a line, so the end of the inset moved forward.
+ # FIXME But we also added some lines, didn't we? I think this
+ # should be j += 1.
j -= 1
# consecutive verbatim environments need to be connected
- k = find_token(document.body, "\\begin_layout Verbatim", j)
+ k = find_token(document.body, "\\begin_layout %s" % (layout_name), j)
if k == j + 2 and consecutive == False:
consecutive = True
- document.body[j:j+1] = ['\end_layout', '', '\\begin_layout Plain Layout']
+ document.body[j:j+1] = ['\\end_layout', '', '\\begin_layout Plain Layout']
document.body[i:i+1] = subst_begin
continue
if k == j + 2 and consecutive == True:
- document.body[j:j+1] = ['\end_layout', '', '\\begin_layout Plain Layout']
+ document.body[j:j+1] = ['\\end_layout', '', '\\begin_layout Plain Layout']
del(document.body[i:i+1])
continue
if k != j + 2 and consecutive == True:
document.body[j:j+1] = subst_end
# the next paragraph must not be indented
+ # FIXME This seems to be causing problems, because of the
+ # hardcoded use of 19. We should figure out exactly where
+ # this needs to go by searching for the right tag.
document.body[j+19:j+19] = ['\\noindent']
del(document.body[i:i+1])
consecutive = False
else:
document.body[j:j+1] = subst_end
# the next paragraph must not be indented
+ # FIXME This seems to be causing problems, because of the
+ # hardcoded use of 19. We should figure out exactly where
+ # this needs to go by searching for the right tag.
document.body[j+19:j+19] = ['\\noindent']
document.body[i:i+1] = subst_begin
def revert_tipa(document):
" Revert native TIPA insets to mathed or ERT. "
i = 0
- while 1:
+ while True:
i = find_token(document.body, "\\begin_inset IPA", i)
if i == -1:
return
put_cmd_in_ert("\\end{turn}")
document.body[i + 4 : i + 4] = \
put_cmd_in_ert("\\begin{turn}{" + value + "}")
-
+
i += 1
-
+
finally:
if load_rotating:
- add_to_preamble(document, ["\\@ifundefined{turnbox}{\usepackage{rotating}}{}"])
+ add_to_preamble(document, ["\\@ifundefined{turnbox}{\\usepackage{rotating}}{}"])
def convert_cell_rotation(document):
rgx = re.compile(r'rotate="[^"]+?"')
# convert "true" to "90"
document.body[i] = rgx.sub('rotate="90"', document.body[i])
-
+
i += 1
put_cmd_in_ert("\\end{turn}")
document.body[i - 2 : i - 2] = \
put_cmd_in_ert("\\begin{turn}{" + value + "}")
-
+
i += 1
-
+
finally:
if load_rotating:
- add_to_preamble(document, ["\\@ifundefined{turnbox}{\usepackage{rotating}}{}"])
+ add_to_preamble(document, ["\\@ifundefined{turnbox}{\\usepackage{rotating}}{}"])
def convert_table_rotation(document):
rgx = re.compile(r'rotate="[^"]+?"')
# convert "true" to "90"
document.body[i] = rgx.sub('rotate="90"', document.body[i])
-
+
i += 1
def revert_ancientgreek(document):
- "Set the document language for ancientgreek to greek"
+ "Set the document language for ancientgreek to greek"
- if document.language == "ancientgreek":
+ if document.language == "ancientgreek":
document.language = "greek"
- i = find_token(document.header, "\\language", 0)
- if i != -1:
- document.header[i] = "\\language greek"
- j = 0
- while True:
- j = find_token(document.body, "\\lang ancientgreek", j)
+ i = find_token(document.header, "\\language", 0)
+ if i != -1:
+ document.header[i] = "\\language greek"
+ j = 0
+ while True:
+ j = find_token(document.body, "\\lang ancientgreek", j)
if j == -1:
return
else:
- document.body[j] = document.body[j].replace("\\lang ancientgreek", "\\lang greek")
+ document.body[j] = document.body[j].replace("\\lang ancientgreek", "\\lang greek")
j += 1
def revert_languages(document):
- "Set the document language for new supported languages to English"
+ "Set the document language for new supported languages to English"
languages = [
"coptic", "divehi", "hindi", "kurmanji", "lao", "marathi", "occitan", "sanskrit",
for n in range(len(languages)):
if document.language == languages[n]:
document.language = "english"
- i = find_token(document.header, "\\language", 0)
- if i != -1:
- document.header[i] = "\\language english"
+ i = find_token(document.header, "\\language", 0)
+ if i != -1:
+ document.header[i] = "\\language english"
j = 0
- while j < len(document.body):
+ while j < len(document.body):
j = find_token(document.body, "\\lang " + languages[n], j)
if j != -1:
document.body[j] = document.body[j].replace("\\lang " + languages[n], "\\lang english")
def convert_armenian(document):
- "Use polyglossia and thus non-TeX fonts for Armenian"
+ "Use polyglossia and thus non-TeX fonts for Armenian"
- if document.language == "armenian":
- i = find_token(document.header, "\\use_non_tex_fonts", 0)
- if i != -1:
- document.header[i] = "\\use_non_tex_fonts true"
+ if document.language == "armenian":
+ i = find_token(document.header, "\\use_non_tex_fonts", 0)
+ if i != -1:
+ document.header[i] = "\\use_non_tex_fonts true"
def revert_armenian(document):
- "Use ArmTeX and thus TeX fonts for Armenian"
+ "Use ArmTeX and thus TeX fonts for Armenian"
- if document.language == "armenian":
- i = find_token(document.header, "\\use_non_tex_fonts", 0)
- if i != -1:
- document.header[i] = "\\use_non_tex_fonts false"
+ if document.language == "armenian":
+ i = find_token(document.header, "\\use_non_tex_fonts", 0)
+ if i != -1:
+ document.header[i] = "\\use_non_tex_fonts false"
def revert_libertine(document):
- " Revert native libertine font definition to LaTeX "
+ " Revert native libertine font definition to LaTeX "
- if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
+ if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
i = find_token(document.header, "\\font_roman libertine", 0)
if i != -1:
osf = False
def revert_txtt(document):
- " Revert native txtt font definition to LaTeX "
+ " Revert native txtt font definition to LaTeX "
- if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
+ if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
i = find_token(document.header, "\\font_typewriter txtt", 0)
if i != -1:
preamble = "\\renewcommand{\\ttdefault}{txtt}"
def revert_mathdesign(document):
- " Revert native mathdesign font definition to LaTeX "
+ " Revert native mathdesign font definition to LaTeX "
- if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
+ if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
mathdesign_dict = {
"mdbch": "charter",
"mdput": "utopia",
if i == -1:
return
val = get_value(document.header, "\\font_roman", i)
- if val in mathdesign_dict.keys():
+ if val in list(mathdesign_dict.keys()):
preamble = "\\usepackage[%s" % mathdesign_dict[val]
expert = False
j = find_token(document.header, "\\font_osf true", 0)
def revert_texgyre(document):
- " Revert native TeXGyre font definition to LaTeX "
+ " Revert native TeXGyre font definition to LaTeX "
- if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
+ if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
texgyre_fonts = ["tgadventor", "tgbonum", "tgchorus", "tgcursor", \
"tgheros", "tgpagella", "tgschola", "tgtermes"]
i = find_token(document.header, "\\font_roman", 0)
i = end
continue
substi = ["\\begin_inset ERT", "status collapsed", "",
- "\\begin_layout Plain Layout", "", "", "\\backslash",
+ "\\begin_layout Plain Layout", "", "", "\\backslash",
decotype + "{", "\\end_layout", "", "\\end_inset"]
substj = ["\\size default", "", "\\begin_inset ERT", "status collapsed", "",
"\\begin_layout Plain Layout", "", "}", "\\end_layout", "", "\\end_inset"]
def revert_minionpro(document):
- " Revert native MinionPro font definition to LaTeX "
+ " Revert native MinionPro font definition to LaTeX "
- if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
+ if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
i = find_token(document.header, "\\font_roman minionpro", 0)
if i != -1:
osf = False
def revert_mathfonts(document):
- " Revert native math font definitions to LaTeX "
+ " Revert native math font definitions to LaTeX "
i = find_token(document.header, "\\font_math", 0)
if i == -1:
return
- if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
+ if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
val = get_value(document.header, "\\font_math", i)
if val == "eulervm":
add_to_preamble(document, "\\usepackage{eulervm}")
k = find_token(document.header, "\\font_osf true", 0)
if k != -1:
rm += "-osf"
- if rm in mathfont_dict.keys():
+ if rm in list(mathfont_dict.keys()):
add_to_preamble(document, mathfont_dict[rm])
document.header[j] = "\\font_roman default"
if k != -1:
def revert_mdnomath(document):
- " Revert mathdesign and fourier without math "
+ " Revert mathdesign and fourier without math "
- if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
+ if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
mathdesign_dict = {
"md-charter": "mdbch",
"md-utopia": "mdput",
if i == -1:
return
val = get_value(document.header, "\\font_roman", i)
- if val in mathdesign_dict.keys():
+ if val in list(mathdesign_dict.keys()):
j = find_token(document.header, "\\font_math", 0)
if j == -1:
document.header[i] = "\\font_roman %s" % mathdesign_dict[val]
document.header[i] = "\\font_roman %s" % mathdesign_dict[val]
+def convert_mathfonts(document):
+ document.header.insert(-1, "\\font_math auto")
+
+
def convert_mdnomath(document):
- " Change mathdesign font name "
+ " Change mathdesign font name "
- if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
+ if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
mathdesign_dict = {
"mdbch": "md-charter",
"mdput": "md-utopia",
if i == -1:
return
val = get_value(document.header, "\\font_roman", i)
- if val in mathdesign_dict.keys():
+ if val in list(mathdesign_dict.keys()):
document.header[i] = "\\font_roman %s" % mathdesign_dict[val]
def revert_newtxmath(document):
- " Revert native newtxmath definitions to LaTeX "
+ " Revert native newtxmath definitions to LaTeX "
i = find_token(document.header, "\\font_math", 0)
if i == -1:
return
- if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
+ if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
val = get_value(document.header, "\\font_math", i)
mathfont_dict = {
"libertine-ntxm": "\\usepackage[libertine]{newtxmath}",
"minion-ntxm": "\\usepackage[minion]{newtxmath}",
"newtxmath": "\\usepackage{newtxmath}",
}
- if val in mathfont_dict.keys():
+ if val in list(mathfont_dict.keys()):
add_to_preamble(document, mathfont_dict[val])
document.header[i] = "\\font_math auto"
def revert_biolinum(document):
- " Revert native biolinum font definition to LaTeX "
+ " Revert native biolinum font definition to LaTeX "
- if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
+ if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
i = find_token(document.header, "\\font_sans biolinum", 0)
if i != -1:
osf = False
document.body[i] = "\\begin_inset Argument 999"
i += 1
continue
-
+
# Find containing paragraph layout
parent = get_containing_layout(document.body, i)
if parent == False:
def revert_IEEEtran(document):
- '''
- Reverts InsetArgument of
- Page headings
- Biography
- Biography without photo
- to TeX-code
- '''
- if document.textclass == "IEEEtran":
+ '''
+ Reverts InsetArgument of
+ Page headings
+ Biography
+ Biography without photo
+ to TeX-code
+ '''
+ if document.textclass != "IEEEtran":
+ return
+
+ layouts = {"Page headings": False,
+ "Biography without photo": True}
+
+ for layout in list(layouts.keys()):
+ i = 0
+ while True:
+ i = find_token(document.body, '\\begin_layout ' + layout, i)
+ if i == -1:
+ break
+ revert_Argument_to_TeX_brace(document, i, 0, 1, 1, layouts[layout], False)
+ i += 1
+
i = 0
- i2 = 0
- j = 0
- k = 0
while True:
- if i != -1:
- i = find_token(document.body, "\\begin_layout Page headings", i)
- if i != -1:
+ i = find_token(document.body, '\\begin_inset Flex Paragraph Start', i)
+ if i == -1:
+ break
revert_Argument_to_TeX_brace(document, i, 0, 1, 1, False, False)
i += 1
- if i2 != -1:
- i2 = find_token(document.body, "\\begin_inset Flex Paragraph Start", i2)
- if i2 != -1:
- revert_Argument_to_TeX_brace(document, i2, 0, 1, 1, False, False)
- i2 = i2 + 1
- if j != -1:
- j = find_token(document.body, "\\begin_layout Biography without photo", j)
- if j != -1:
- revert_Argument_to_TeX_brace(document, j, 0, 1, 1, True, False)
- j += 1
- if k != -1:
- k = find_token(document.body, "\\begin_layout Biography", k)
- kA = find_token(document.body, "\\begin_layout Biography without photo", k)
- if k == kA and k != -1:
- k += 1
- continue
- if k != -1:
+
+ i = 0
+ while True:
+ i = find_token_exact(document.body, "\\begin_layout Biography", i)
+ if i == -1:
+ break
+
+ if document.body[i] == "\\begin_layout Biography without photo":
+ i += 1
+ continue
+
# start with the second argument, therefore 2
- revert_Argument_to_TeX_brace(document, k, 0, 2, 2, True, False)
- k += 1
- if i == -1 and i2 == -1 and j == -1 and k == -1:
- return
+ revert_Argument_to_TeX_brace(document, i, 0, 2, 2, True, False)
+ i += 1
def revert_IEEEtran_2(document):
def convert_IEEEtran(document):
- '''
- Converts ERT of
- Page headings
- Biography
- Biography without photo
- to InsetArgument
- '''
- if document.textclass == "IEEEtran":
+ '''
+ Converts ERT of
+ Page headings
+ Biography
+ Biography without photo
+ to InsetArgument
+ '''
+ if document.textclass != "IEEEtran":
+ return
+
+ layouts = {"Page headings": False,
+ "Biography without photo": True}
+
+ for layout in list(layouts.keys()):
+ i = 0
+ while True:
+ i = find_token(document.body, '\\begin_layout ' + layout, i)
+ if i == -1:
+ break
+ convert_TeX_brace_to_Argument(document, i, 1, 1, False, layouts[layout], False)
+ i += 1
+
i = 0
- j = 0
- k = 0
while True:
- if i != -1:
- i = find_token(document.body, "\\begin_layout Page headings", i)
- if i != -1:
- convert_TeX_brace_to_Argument(document, i, 1, 1, False, False, False)
- i += 1
- if j != -1:
- j = find_token(document.body, "\\begin_layout Biography without photo", j)
- if j != -1:
- convert_TeX_brace_to_Argument(document, j, 1, 1, False, True, False)
- j += 1
- if k != -1:
- # assure that we don't handle Biography Biography without photo
- k = find_token(document.body, "\\begin_layout Biography", k)
- kA = find_token(document.body, "\\begin_layout Biography without photo", k - 1)
- if k == kA and k != -1:
- k += 1
- continue
- if k != -1:
+ i = find_token_exact(document.body, "\\begin_layout Biography", i)
+ if i == -1:
+ break
+
+ if document.body[i] == "\\begin_layout Biography without photo":
+ i += 1
+ continue
+
# the argument we want to convert is the second one
- convert_TeX_brace_to_Argument(document, k, 2, 2, False, True, False)
- k += 1
- if i == -1 and j == -1 and k == -1:
- return
+ convert_TeX_brace_to_Argument(document, i, 2, 2, False, True, False)
+ i += 1
def revert_AASTeX(document):
def convert_literate(document):
" Convert Literate document to new format"
- i = find_token(document.header, "\\textclass", 0)
+ i = find_token(document.header, "\\textclass", 0)
if (i != -1) and "literate-" in document.header[i]:
document.textclass = document.header[i].replace("\\textclass literate-", "")
j = find_token(document.header, "\\begin_modules", 0)
def revert_garamondx_newtxmath(document):
- " Revert native garamond newtxmath definition to LaTeX "
+ " Revert native garamond newtxmath definition to LaTeX "
i = find_token(document.header, "\\font_math", 0)
if i == -1:
return
- if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
+ if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
val = get_value(document.header, "\\font_math", i)
if val == "garamondx-ntxm":
add_to_preamble(document, "\\usepackage[garamondx]{newtxmath}")
def revert_garamondx(document):
- " Revert native garamond font definition to LaTeX "
+ " Revert native garamond font definition to LaTeX "
- if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
+ if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
i = find_token(document.header, "\\font_roman garamondx", 0)
if i != -1:
osf = False
def convert_beamerargs(document):
" Converts beamer arguments to new layout "
-
+
beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
if document.textclass not in beamer_classes:
return
beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
if document.textclass not in beamer_classes:
return
-
+
i = 0
while True:
i = find_token(document.body, "\\begin_layout AgainFrame", i)
def convert_corollary_args(document):
" Converts beamer corrolary-style ERT arguments native InsetArgs "
-
+
beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
if document.textclass not in beamer_classes:
return
-
+
corollary_layouts = ["Corollary", "Definition", "Definitions", "Example", "Examples", "Fact", "Proof", "Theorem"]
for lay in corollary_layouts:
i = 0
document.body[parbeg] = "\\begin_inset Argument 1"
elif document.body[ertcontlastline].endswith("]"):
# divide the args
- ertcontdivline = document.body[ertcontfirstline].find('>[')
- if ertcontdivline != -1:
+ tok = document.body[ertcontfirstline].find('>[')
+ if tok != -1:
if ertcontfirstline < ertcontlastline:
# Multiline ERT. Might contain TeX code. Embrace in ERT.
document.body[ertcontlastline : ertcontlastline + 1] = [
document.body[ertcontlastline], '\\end_layout', '', '\\end_inset']
- document.body[ertcontdivline : ertcontdivline + 1] = [document.body[ertcontdivline][:tok],
+ document.body[ertcontfirstline : ertcontfirstline + 1] = [document.body[ertcontfirstline][:tok],
'\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 2',
'status collapsed', '', '\\begin_layout Plain Layout',
'\\begin_inset ERT', '', 'status open' '', '\\begin_layout Plain Layout',
- document.body[ertcontdivline][tok + 2:]]
+ document.body[ertcontfirstline][tok + 2:-1]]
else:
- document.body[ertcontdivline : ertcontdivline + 1] = [document.body[ertcontdivline][:tok],
+ document.body[ertcontfirstline : ertcontfirstline + 1] = [document.body[ertcontfirstline][:tok],
'\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 2',
'status collapsed', '', '\\begin_layout Plain Layout',
- document.body[ertcontdivline][tok + 2:]]
+ document.body[ertcontfirstline][tok + 2:-1]]
# Convert to ArgInset
document.body[parbeg] = "\\begin_inset Argument 1"
i = j
def convert_quote_args(document):
" Converts beamer quote style ERT args to native InsetArgs "
-
+
beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
if document.textclass not in beamer_classes:
return
-
+
quote_layouts = ["Uncover", "Only", "Quotation", "Quote", "Verse"]
for lay in quote_layouts:
i = 0
def revert_beamerargs(document):
" Reverts beamer arguments to old layout "
-
+
beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
if document.textclass not in beamer_classes:
return
endPlain = find_end_of_layout(document.body, beginPlain)
content = document.body[beginPlain + 1 : endPlain]
del document.body[i:j+1]
- subst = put_cmd_in_ert("[") + content + put_cmd_in_ert("]")
- document.body[realparbeg : realparbeg] = subst
+ if layoutname == "Description":
+ # Description only has one (overlay) item arg
+ subst = put_cmd_in_ert("<") + content + put_cmd_in_ert(">")
+ # This must be put after the first space (begin of decription body
+ # in LyX's arkward description list syntax)
+ # Try to find that place ...
+ rxx = re.compile(r'^([^\\ ]+ )(.*)$')
+ for q in range(parbeg, parend):
+ m = rxx.match(document.body[q])
+ if m:
+ # We found it. Now insert the ERT argument just there:
+ document.body[q : q] = [m.group(1), ''] + subst + ['', m.group(2)]
+ break
+ else:
+ subst = put_cmd_in_ert("[") + content + put_cmd_in_ert("]")
+ document.body[realparbeg : realparbeg] = subst
elif argnr == "item:2":
j = find_end_of_inset(document.body, i)
# Find containing paragraph layout
del document.body[p : endInset + 1]
subst = put_cmd_in_ert("[") + content + put_cmd_in_ert("]")
document.body[realparbeg : realparbeg] = subst
-
+
i = realparend
def revert_beamerargs2(document):
" Reverts beamer arguments to old layout, step 2 "
-
+
beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
if document.textclass not in beamer_classes:
return
if m:
argnr = m.group(1)
if argnr == "2":
- document.body[p] = "\\begin_inset Argument 1"
+ document.body[p] = "\\begin_inset Argument 1"
if layoutname in corollary_layouts:
m = rx.match(document.body[p])
if m:
def revert_beamerargs3(document):
" Reverts beamer arguments to old layout, step 3 "
-
+
beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
if document.textclass not in beamer_classes:
return
def revert_beamerflex(document):
" Reverts beamer Flex insets "
-
+
beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
if document.textclass not in beamer_classes:
return
document.body[i : beginPlain + 1] = pre
post = put_cmd_in_ert("}")
document.body[z - 2 : z + 1] = post
-
+
i += 1
def revert_beamerblocks(document):
" Reverts beamer block arguments to ERT "
-
+
beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
if document.textclass not in beamer_classes:
return
def convert_beamerblocks(document):
" Converts beamer block ERT args to native InsetArgs "
-
+
beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
if document.textclass not in beamer_classes:
return
-
+
blocks = ["Block", "ExampleBlock", "AlertBlock"]
for lay in blocks:
i = 0
parend = parent[2]
j = parend
if i != -1:
+ # If the paragraph starts with a language switch, adjust parbeg
+ if len(document.body[parbeg]) == 0 and parbeg < parend \
+ and document.body[parbeg + 1].startswith("\\lang"):
+ parbeg += 2
if document.body[parbeg] == "\\begin_inset ERT":
ertcontfirstline = parbeg + 5
lastertbeg = -1
document.body[ertcontlastline : ertcontlastline + 1] = [
document.body[ertcontlastline], '\\end_layout', '', '\\end_inset']
document.body[ertcontdivline : ertcontdivlinetwo + 1] = [document.body[ertcontdivline][:tok],
- '\\end_layout', '', '\\end_inset', '', '\\end_layout', '',
+ '\\end_layout', '', '\\end_inset', '', '\\end_layout', '',
'\\end_inset', '', '', '\\begin_inset Argument 2',
'status collapsed', '', '\\begin_layout Plain Layout',
'\\begin_inset ERT', '', 'status open' '', '\\begin_layout Plain Layout',
# Multiline ERT. Might contain TeX code. Embrace in ERT.
document.body[ertcontlastline : ertcontlastline + 1] = [
document.body[ertcontlastline], '\\end_layout', '', '\\end_inset']
- document.body[ertcontdivline : ertcontdivline + 1] = [document.body[ertcontdivline][:tok],
- '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 1',
- 'status collapsed', '', '\\begin_layout Plain Layout',
- '\\begin_inset ERT', '', 'status open' '', '\\begin_layout Plain Layout',
- document.body[ertcontdivline][tok + 2:]]
+ if ertcontdivline == ertcontfirstline:
+ document.body[ertcontdivline : ertcontdivline + 1] = [document.body[ertcontdivline][:tok],
+ '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 1',
+ 'status collapsed', '', '\\begin_layout Plain Layout',
+ '\\begin_inset ERT', '', 'status open' '', '\\begin_layout Plain Layout',
+ document.body[ertcontdivline][tok + 2:]]
+ else:
+ document.body[ertcontdivline : ertcontdivline + 1] = [document.body[ertcontdivline][:tok],
+ '\\end_layout', '', '\\end_inset', '',
+ '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 1',
+ 'status collapsed', '', '\\begin_layout Plain Layout',
+ '\\begin_inset ERT', '', 'status open' '', '\\begin_layout Plain Layout',
+ document.body[ertcontdivline][tok + 2:]]
else:
document.body[ertcontdivline : ertcontdivline + 1] = [document.body[ertcontdivline][:tok],
'\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 1',
document.body[ertcontlastline : ertcontlastline + 1] = [
document.body[ertcontlastline], '\\end_layout', '', '\\end_inset']
document.body[ertcontdivline : ertcontdivlinetwo + 1] = [document.body[ertcontdivline][:tok],
- '\\end_layout', '', '\\end_inset', '', '\\end_layout', '',
+ '\\end_layout', '', '\\end_inset', '', '\\end_layout', '',
'\\end_inset', '', '', '\\begin_inset Argument 1',
'status collapsed', '', '\\begin_layout Plain Layout',
'\\begin_inset ERT', '', 'status open' '', '\\begin_layout Plain Layout',
def convert_overprint(document):
" Convert old beamer overprint layouts to ERT "
-
+
beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
if document.textclass not in beamer_classes:
return
# Remove arg inset
del document.body[argbeg : argend + 1]
subst += put_cmd_in_ert("[") + content + put_cmd_in_ert("]")
-
+
endseq = endseq - len(document.body[i : i])
document.body[i : i] = subst + ["\\end_layout"]
endseq += len(subst)
-
+
for p in range(i, endseq):
if document.body[p] == "\\begin_layout Overprint":
document.body[p] = "\\begin_layout Standard"
def revert_overprint(document):
" Revert old beamer overprint layouts to ERT "
-
+
beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
if document.textclass not in beamer_classes:
return
# Remove arg inset
del document.body[argbeg : argend + 1]
subst += put_cmd_in_ert("[") + content + put_cmd_in_ert("]")
-
+
endseq = endseq - len(document.body[i : i])
document.body[i : i] = subst + ["\\end_layout"]
endseq += len(subst)
-
+
p = i
while True:
if p >= endseq:
def revert_frametitle(document):
" Reverts beamer frametitle layout to ERT "
-
+
beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
if document.textclass not in beamer_classes:
return
# Remove arg inset
del document.body[p : endInset + 1]
subst += put_cmd_in_ert("[") + content + put_cmd_in_ert("]")
-
+
subst += put_cmd_in_ert("{")
document.body[i : i + 1] = subst
i = endlay
def convert_epigraph(document):
" Converts memoir epigraph to new syntax "
-
+
if document.textclass != "memoir":
return
endlay += len(begsubst) + len(endsubst)
endlay = endlay - len(document.body[ert : endInset + 1])
del document.body[ert : endInset + 1]
-
+
i = endlay
def revert_epigraph(document):
" Reverts memoir epigraph argument to ERT "
-
+
if document.textclass != "memoir":
return
subst += put_cmd_in_ert("}{") + content
else:
subst += put_cmd_in_ert("}{")
-
+
document.body[j : j] = subst + document.body[j : j]
i = endlay
def convert_captioninsets(document):
" Converts caption insets to new syntax "
-
+
i = 0
while True:
i = find_token(document.body, "\\begin_inset Caption", i)
def revert_captioninsets(document):
" Reverts caption insets to old syntax "
-
+
i = 0
while True:
i = find_token(document.body, "\\begin_inset Caption Standard", i)
"Bicaption" : "Bicaption",
}
- i = 0
- while True:
- i = find_token(document.body, "\\begin_layout", i)
- if i == -1:
- return
- val = get_value(document.body, "\\begin_layout", i)
- if val in caption_dict.keys():
+ for captype in caption_dict.keys():
+ i = 0
+ while True:
+ i = find_token(document.body, "\\begin_layout " + captype, i)
+ if i == -1:
+ break
j = find_end_of_layout(document.body, i)
if j == -1:
document.warning("Malformed LyX document: Missing `\\end_layout'.")
- return
+ break
document.body[j:j] = ["\\end_layout", "", "\\end_inset", "", ""]
document.body[i:i+1] = ["\\begin_layout %s" % document.default_layout,
- "\\begin_inset Caption %s" % caption_dict[val], "",
+ "\\begin_inset Caption %s" % caption_dict[captype], "",
"\\begin_layout %s" % document.default_layout]
- i += 1
+ i = j + 1
def revert_captionlayouts(document):
" Revert caption insets to caption layouts. "
-
+
caption_dict = {
"Above" : "Captionabove",
"Below" : "Captionbelow",
"Centered" : "CenteredCaption",
"Bicaption" : "Bicaption",
}
-
+
i = 0
rx = re.compile(r'^\\begin_inset Caption (\S+)$')
while True:
val = ""
if m:
val = m.group(1)
- if val not in caption_dict.keys():
+ if val not in list(caption_dict.keys()):
i += 1
continue
-
+
# We either need to delete the previous \begin_layout line, or we
# need to end the previous layout if this inset is not in the first
# position of the paragraph.
def revert_fragileframe(document):
" Reverts beamer FragileFrame layout to ERT "
-
+
beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
if document.textclass not in beamer_classes:
return
subst += put_cmd_in_ert("{") + content + put_cmd_in_ert("}")
elif p == 3:
subst += put_cmd_in_ert("[fragile]")
-
+
document.body[i : i + 1] = subst
i = j
def revert_newframes(document):
" Reverts beamer Frame and PlainFrame layouts to old forms "
-
+
beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
if document.textclass not in beamer_classes:
return
val = ""
if m:
val = m.group(1)
- if val not in frame_dict.keys():
+ if val not in list(frame_dict.keys()):
i += 1
continue
# Find end of sequence
# Remove arg inset
del document.body[arg : endInset + 1]
subst += content
-
+
document.body[i : i + 1] = subst
i = j
if i == -1:
return
val = get_value(document.header, "\\inputencoding", i)
- if val in LaTeX2LyX_enc_dict.keys():
+ if val in list(LaTeX2LyX_enc_dict.keys()):
document.header[i] = "\\inputencoding %s" % LaTeX2LyX_enc_dict[val]
elif val not in known_enc_tuple:
document.warning("Ignoring unknown input encoding: `%s'" % val)
if i == -1:
return
val = get_value(document.header, "\\inputencoding", i)
- if val in LyX2LaTeX_enc_dict.keys():
+ if val in list(LyX2LaTeX_enc_dict.keys()):
document.header[i] = "\\inputencoding %s" % LyX2LaTeX_enc_dict[val]
elif val not in known_enc_tuple:
document.warning("Ignoring unknown input encoding: `%s'" % val)
def revert_kurier_fonts(document):
" Revert kurier font definition to LaTeX "
-
+
i = find_token(document.header, "\\font_math", 0)
if i != -1:
- if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
+ if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
val = get_value(document.header, "\\font_math", i)
if val == "kurier-math":
add_to_preamble(document, "\\let\\Myrmdefault\\rmdefault\n" \
"\\usepackage[math]{kurier}\n" \
"\\renewcommand{\\rmdefault}{\\Myrmdefault}")
document.header[i] = "\\font_math auto"
-
- if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
+
+ if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
kurier_fonts = ["kurier", "kurierc", "kurierl", "kurierlc"]
k = find_token(document.header, "\\font_sans kurier", 0)
if k != -1:
def revert_iwona_fonts(document):
" Revert iwona font definition to LaTeX "
-
+
i = find_token(document.header, "\\font_math", 0)
if i != -1:
- if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
+ if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
val = get_value(document.header, "\\font_math", i)
if val == "iwona-math":
add_to_preamble(document, "\\let\\Myrmdefault\\rmdefault\n" \
"\\usepackage[math]{iwona}\n" \
"\\renewcommand{\\rmdefault}{\\Myrmdefault}")
document.header[i] = "\\font_math auto"
-
- if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
+
+ if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
iwona_fonts = ["iwona", "iwonac", "iwonal", "iwonalc"]
k = find_token(document.header, "\\font_sans iwona", 0)
if k != -1:
def revert_new_libertines(document):
" Revert new libertine font definition to LaTeX "
-
+
if find_token(document.header, "\\use_non_tex_fonts true", 0) != -1:
return
preamble += "{libertineMono-type1}"
add_to_preamble(document, [preamble])
document.header[i] = "\\font_typewriter default"
-
+
k = find_token(document.header, "\\font_sans biolinum", 0)
if k != -1:
preamble = "\\usepackage"
def convert_lyxframes(document):
" Converts old beamer frames to new style "
-
+
beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
if document.textclass not in beamer_classes:
return
-
+
framebeg = ["BeginFrame", "BeginPlainFrame"]
frameend = ["Frame", "PlainFrame", "EndFrame", "BeginFrame", "BeginPlainFrame", "AgainFrame",
"Section", "Section*", "Subsection", "Subsection*", "Subsubsection", "Subsubsection*"]
# Step III: find real frame end
j = j + 8
jj = j
+ inInset = get_containing_inset(document.body, i)
while True:
fend = find_token(document.body, "\\begin_layout", jj)
if fend == -1:
if val not in frameend:
jj = fend + 1
continue
- old = document.body[fend]
+ # is this frame nested in an inset (e.g., Note)?
+ if inInset != False:
+ # if so, end the frame inside the inset
+ if inInset[2] < fend:
+ fend = inInset[2]
if val == frametype:
document.body[fend : fend] = ['\\end_deeper', '', '\\begin_layout Separator', '', '\\end_layout']
# consider explicit EndFrames between two identical frame types
def remove_endframes(document):
" Remove deprecated beamer endframes "
-
+
beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
if document.textclass not in beamer_classes:
return
-
+
i = 0
while True:
i = find_token_exact(document.body, "\\begin_layout EndFrame", i)
def revert_powerdot_flexes(document):
" Reverts powerdot flex insets "
-
+
if document.textclass != "powerdot":
return
z += len(pre)
document.body[i : beginPlain + 1] = pre
post = put_cmd_in_ert("}")
- document.body[z - 2 : z + 1] = post
+ document.body[z - 2 : z + 1] = post
i += 1
def revert_powerdot_pause(document):
" Reverts powerdot pause layout to ERT "
-
+
if document.textclass != "powerdot":
return
# Remove arg inset
del document.body[p : endInset + 1]
subst += put_cmd_in_ert("[") + content + put_cmd_in_ert("]")
-
+
document.body[i : i + 1] = subst
i = endlay
def revert_powerdot_itemargs(document):
" Reverts powerdot item arguments to ERT "
-
+
if document.textclass != "powerdot":
return
del document.body[i:j+1]
subst = put_cmd_in_ert("<") + content + put_cmd_in_ert(">")
document.body[realparbeg : realparbeg] = subst
-
+
i = realparend
# Remove arg inset
del document.body[p : endInset + 1]
subst += put_cmd_in_ert("{") + content + put_cmd_in_ert("}")
-
+
subst += put_cmd_in_ert("{")
document.body[i : i + 1] = subst
i = endlay
def revert_starred_caption(document):
" Reverts unnumbered longtable caption insets "
-
+
i = 0
while True:
i = find_token(document.body, "\\begin_inset Caption LongTableNoNumber", i)
def revert_tibetan(document):
- "Set the document language for Tibetan to English"
+ "Set the document language for Tibetan to English"
if document.language == "tibetan":
document.language = "english"
- i = find_token(document.header, "\\language", 0)
- if i != -1:
- document.header[i] = "\\language english"
+ i = find_token(document.header, "\\language", 0)
+ if i != -1:
+ document.header[i] = "\\language english"
j = 0
- while j < len(document.body):
+ while j < len(document.body):
j = find_token(document.body, "\\lang tibetan", j)
if j != -1:
document.body[j] = document.body[j].replace("\\lang tibetan", "\\lang english")
# there is no point continuing, as we will run into the same error again.
return
this_chunk = "".join(document.body[i + 1:j])
-
+
# there may be empty lines between chunks
# we just skip them.
if not chunk_started:
if this_chunk != "":
# new chunk starts
chunk_started = True
-
+
if chunk_started:
contents.append(document.body[i + 1:j])
# look for potential chunk terminator
- # on the last line of the chunk paragraph
+ # on the last line of the chunk paragraph
if document.body[j - 1] == "@":
break
break
file_pos = end = j + 1
-
+
# The last chunk should simply have an "@" in it
# or at least end with "@" (can happen if @ is
# preceded by a newline)
- lastpar = ''.join(contents[-1])
+ lastpar = ''
+ if len(contents) > 0:
+ lastpar = ''.join(contents[-1])
if not lastpar.endswith("@"):
document.warning("Unexpected chunk content: chunk not terminated by '@'!")
+ if len(contents) == 0:
+ # convert empty chunk layouts to Standard
+ document.body[start] = "\\begin_layout Standard"
continue
if lastpar == "@":
# the first par (separated from the options by a newline).
# We collect such stuff to re-insert it later.
postoptstuff = []
-
+
match = first_re.search(optarg)
if match:
optarg = match.groups()[0]
# We have stripped everything. This can be deleted.
contents.pop(0)
- newstuff = ['\\begin_layout Standard',
- '\\begin_inset Flex Chunk',
- 'status open', '',
- '\\begin_layout Plain Layout', '']
+ newstuff = ['\\begin_layout Standard']
+
+ # Maintain paragraph parameters
+ par_params = ["\\noindent", "\\indent", "\\indent-toggle", "\\leftindent",
+ "\\start_of_appendix", "\\paragraph_spacing", "\\align",
+ "\\labelwidthstring"]
+ parms = start + 1
+ while True:
+ if document.body[parms].split(' ', 1)[0] not in par_params:
+ break
+ newstuff.extend([document.body[parms]])
+ parms += 1
+
+ newstuff.extend(
+ ['\\begin_inset Flex Chunk',
+ 'status open', '',
+ '\\begin_layout Plain Layout', ''])
# If we have a non-empty optional argument, insert it.
if match and optarg != "":
# does not need to do that.
did_one_par = False
if postoptstuff:
- newstuff.extend(postoptstuff)
+ # we need to replace newlines with new layouts
+ start_newline = -1
+ started_text = False
+ for lno in range(0,len(postoptstuff)):
+ if postoptstuff[lno].startswith("\\begin_inset Newline newline"):
+ start_newline = lno
+ elif start_newline != -1:
+ if postoptstuff[lno].startswith("\\end_inset"):
+ # replace that bit, but only if we already have some text
+ # and we're not at the end except for a blank line
+ if started_text and \
+ (lno != len(postoptstuff) - 2 or postoptstuff[-1] != ""):
+ newstuff.extend(['\\end_layout', '\n', '\\begin_layout Plain Layout', '\n'])
+ start_newline = -1
+ started_text = True
+ else:
+ newstuff.extend([postoptstuff[lno]])
newstuff.append('\\end_layout')
did_one_par = True
for c in contents:
continue
# Look for optional argument
- have_optarg = False
+ optarg = ""
ostart = find_token(document.body, "\\begin_inset Argument 1", i, iend)
if ostart != -1:
oend = find_end_of_inset(document.body, ostart)
else:
m = find_end_of_layout(document.body, k)
optarg = "".join(document.body[k+1:m])
- have_optarg = True
# We now remove the optional argument, so we have something
# uniform on which to work
k = j
# we now need to wrap all of these paragraphs in chunks
newlines = []
- if have_optarg:
- newlines.extend(["\\begin_layout Chunk", "", "<<" + optarg + ">>=", "\\end_layout", ""])
+ newlines.extend(["\\begin_layout Chunk", "", "<<" + optarg + ">>=", "\\end_layout", ""])
for stuff in parlist:
newlines.extend(["\\begin_layout Chunk"] + stuff + ["\\end_layout", ""])
newlines.extend(["\\begin_layout Chunk", "", "@", "\\end_layout", ""])
# replace old content with new content
document.body[lstart : lend + 1] = newlines
i = lstart + len(newlines)
-
+
##
# Conversion hub
[437, []],
[438, []],
[439, []],
- [440, []],
+ [440, [convert_mathfonts]],
[441, [convert_mdnomath]],
[442, []],
[443, []],
projects / lyx.git / blobdiff