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
n += 1
endn = end
loop += 1
- # now check the case that we have "}" + "{" in two ERTs
- else: # no brace pair found
+ else:
+ # no brace pair found
+ # now check the case that we have "}" + "{" in two ERTs
if opt:
endBrace = find_token(document.body, "]", lineERT, end_layout)
else:
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:
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:
- end_ERT2 = find_end_of_inset(document.body, lineERT)
+ 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!!")
break
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
###############################################################################
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 convert_justification(document):
" Add the \\justification buffer param"
- i = find_token(document.header, "\\use_indices" , 0)
+ i = find_token(document.header, "\\suppress_date" , 0)
+ if i == -1:
+ i = find_token(document.header, "\\paperorientation" , 0)
if i == -1:
- document.warning("Malformed LyX document: Missing \\use_indices.")
+ i = find_token(document.header, "\\use_indices" , 0)
+ if i == -1:
+ i = find_token(document.header, "\\use_bibtopic" , 0)
+ if i == -1:
+ document.warning("Malformed LyX document: Missing \\suppress_date.")
return
document.header.insert(i + 1, "\\justification true")
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)
+ 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)
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
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)
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:
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 "
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]
"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"
"svglobal3", "svglobal", "svjog", "svmono", "svmult", "svprobth", "tarticle",
"tbook", "treport", "tufte-book", "tufte-handout"]
# A list of "safe" modules, same as above
- safe_modules = ["biblatex", "beameraddons", "beamersession", "braille", "customHeadersFooters",
- "endnotes", "enumitem", "eqs-within-sections", "figs-within-sections", "fix-cm",
- "fixltx2e", "foottoend", "hanging", "jscharstyles", "knitr", "lilypond",
+ safe_modules = ["biblatex", "beameraddons", "beamer-resenumerate", "beamersession", "braille",
+ "customHeadersFooters", "endnotes", "enumitem", "eqs-within-sections", "figs-within-sections",
+ "fix-cm", "fixltx2e", "foottoend", "hanging", "jscharstyles", "knitr", "lilypond",
"linguistics", "linguisticx", "logicalmkup", "minimalistic", "nomindex", "noweb",
"pdfcomment", "sweave", "tabs-within-sections", "theorems-ams-bytype",
"theorems-ams-extended-bytype", "theorems-ams-extended", "theorems-ams", "theorems-bytype",
if argnr > allowed_opts and argnr < first_req:
argnr = first_req
document.body[p] = "\\begin_inset Argument %d" % argnr
- i += 1
+ i = parend + 1
def revert_latexargs(document):
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):
parbeg = parent[3]
if i != -1:
if document.body[parbeg] == "\\begin_inset ERT":
- ertcont = parbeg + 5
- if document.body[ertcont].startswith("<"):
+ ertcontfirstline = parbeg + 5
+ # Find the last ERT in this paragraph (which might also be the first)
+ lastertbeg = find_token_backwards(document.body, "\\begin_inset ERT", j)
+ if lastertbeg == -1:
+ document.warning("Last ERT not found!")
+ break
+ lastertend = find_end_of_inset(document.body, lastertbeg)
+ if lastertend == -1:
+ document.warning("End of last ERT not found!")
+ break
+ ertcontlastline = lastertend - 3
+ if document.body[ertcontfirstline].startswith("<"):
# This is an overlay specification
# strip off the <
- document.body[ertcont] = document.body[ertcont][1:]
- if document.body[ertcont].endswith(">"):
+ document.body[ertcontfirstline] = document.body[ertcontfirstline][1:]
+ if document.body[ertcontlastline].endswith(">"):
# strip off the >
- document.body[ertcont] = document.body[ertcont][:-1]
- elif document.body[ertcont].endswith("]"):
+ document.body[ertcontlastline] = document.body[ertcontlastline][:-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[ertcontfirstline : ertcontfirstline + 1] = [
+ '\\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[ertcontfirstline]]
+ else:
+ # Convert to ArgInset
+ document.body[parbeg] = "\\begin_inset Argument 1"
+ elif document.body[ertcontlastline].endswith("]"):
# divide the args
- tok = document.body[ertcont].find('>[')
+ tok = document.body[ertcontfirstline].find('>[')
if tok != -1:
- subst = [document.body[ertcont][:tok],
- '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 2',
- 'status collapsed', '', '\\begin_layout Plain Layout',
- document.body[ertcont][tok + 2:-1]]
- document.body[ertcont : ertcont + 1] = subst
- # Convert to ArgInset
- document.body[parbeg] = "\\begin_inset Argument 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[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[ertcontfirstline][tok + 2:-1]]
+ else:
+ 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[ertcontfirstline][tok + 2:-1]]
+ # Convert to ArgInset
+ document.body[parbeg] = "\\begin_inset Argument 1"
i = j
continue
- elif document.body[ertcont].startswith("["):
- if document.body[ertcont].endswith("]"):
+ elif document.body[ertcontlastline].startswith("["):
+ if document.body[ertcontlastline].endswith("]"):
# This is an ERT option
# strip off the [
- document.body[ertcont] = document.body[ertcont][1:]
+ document.body[ertcontlastline] = document.body[ertcontlastline][1:]
# strip off the ]
- document.body[ertcont] = document.body[ertcont][:-1]
+ document.body[ertcontlastline] = document.body[ertcontlastline][:-1]
# Convert to ArgInset
document.body[parbeg] = "\\begin_inset Argument 2"
else:
i = j
+def cleanup_beamerargs(document):
+ " Clean up empty ERTs (conversion artefacts) "
+
+ 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_inset Argument", i)
+ if i == -1:
+ return
+ j = find_end_of_inset(document.body, i)
+ if j == -1:
+ document.warning("Malformed LyX document: Can't find end of Argument inset")
+ i += 1
+ continue
+ while True:
+ ertbeg = find_token(document.body, "\\begin_inset ERT", i, j)
+ if ertbeg == -1:
+ break
+ ertend = find_end_of_inset(document.body, ertbeg)
+ if ertend == -1:
+ document.warning("Malformed LyX document: Can't find end of ERT inset")
+ break
+ stripped = [line for line in document.body[ertbeg : ertend + 1] if line.strip()]
+ if len(stripped) == 5:
+ # This is an empty ERT
+ offset = len(document.body[ertbeg : ertend + 1])
+ del document.body[ertbeg : ertend + 1]
+ j = j - offset
+ else:
+ i = ertend
+ i += 1
+
+
def revert_beamerargs(document):
" Reverts beamer arguments to old layout "
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
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
- # Find the last ERT in this paragraph (which might also be the first)
- lastertbeg = find_token_backwards(document.body, "\\begin_inset ERT", j)
- if lastertbeg == -1:
- document.warning("Last ERT not found!")
- break
- lastertend = find_end_of_inset(document.body, lastertbeg)
- if lastertend == -1:
- document.warning("End of last ERT not found!")
+ lastertbeg = -1
+ lastertend = -1
+ while True:
+ # Find the last ERT in this paragraph used for arguments
+ # (which might also be the first)
+ lastertbeg = find_token_backwards(document.body, "\\begin_inset ERT", j)
+ if lastertbeg == -1:
+ document.warning("Last ERT not found!")
+ break
+ lastertend = find_end_of_inset(document.body, lastertbeg)
+ if lastertend == -1:
+ document.warning("End of last ERT not found!")
+ break
+ # Is this ERT really used for an argument?
+ # Note: This will fail when non-argument ERTs actually use brackets
+ # (e.g. \pause{})
+ regexp = re.compile(r'.*[>\]\}]', re.IGNORECASE)
+ cbracket = find_re(document.body, regexp, lastertbeg, lastertend)
+ if cbracket != -1:
+ break
+ if lastertbeg == parbeg:
+ break
+ j = lastertbeg - 1
+ if lastertbeg == -1 or lastertend == -1:
break
ertcontlastline = lastertend - 3
while True:
tok = document.body[ertcontdivline].find('>{')
if tok == -1:
regexp = re.compile(r'.*>\{', re.IGNORECASE)
- ertcontdivline = find_re(document.body, regexp, ertcontfirstline, ertcontlastline)
+ ertcontdivline = find_re(document.body, regexp, ertcontfirstline, lastertend)
tok = document.body[ertcontdivline].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],
- '\\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:]]
+ if ertcontdivline == ertcontfirstline:
+ document.body[ertcontdivline : ertcontdivline + 1] = [document.body[ertcontdivline][:tok],
+ '\\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',
+ document.body[ertcontdivline][tok + 2:]]
+ else:
+ document.body[ertcontdivline : ertcontdivline + 1] = [document.body[ertcontdivline][: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:]]
else:
document.body[ertcontdivline : ertcontdivline + 1] = [document.body[ertcontdivline][:tok],
'\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 2',
'status collapsed', '', '\\begin_layout Plain Layout',
document.body[ertcontdivline][tok + 2:]]
- # Convert to ArgInset
- document.body[parbeg] = "\\begin_inset Argument 1"
+ else:
+ # check if have delimiters in two different ERTs
+ tok = document.body[ertcontdivline].find('>')
+ if tok == -1:
+ regexp = re.compile(r'.*>', re.IGNORECASE)
+ ertcontdivline = find_re(document.body, regexp, ertcontfirstline, lastertend)
+ tok = document.body[ertcontdivline].find('>')
+ if tok != -1:
+ tokk = document.body[ertcontdivline].find('{')
+ if tokk == -1:
+ regexp = re.compile(r'.*\{', re.IGNORECASE)
+ ertcontdivlinetwo = find_re(document.body, regexp, ertcontfirstline, lastertend)
+ tokk = document.body[ertcontdivlinetwo].find('{')
+ if tokk != -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 : ertcontdivlinetwo + 1] = [document.body[ertcontdivline][:tok],
+ '\\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',
+ document.body[ertcontdivlinetwo][tokk + 1:]]
+ else:
+ document.body[ertcontdivline : ertcontdivlinetwo + 1] = [document.body[ertcontdivline][:tok],
+ '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 2',
+ 'status collapsed', '', '\\begin_layout Plain Layout',
+ document.body[ertcontdivlinetwo][tokk + 1:]]
+ # Convert to ArgInset
+ if ertcontfirstline < ertcontlastline:
+ # Multiline ERT. Might contain TeX code. Embrace in ERT.
+ document.body[parbeg : parbeg + 1] = ['\\begin_inset Argument 1',
+ 'status collapsed', '', '\\begin_layout Plain Layout',
+ '\\begin_inset ERT', '']
+ else:
+ document.body[parbeg] = "\\begin_inset Argument 1"
elif document.body[ertcontfirstline].lstrip().startswith("{"):
# This is the block title
if document.body[ertcontlastline].rstrip().endswith("}"):
if ertcontfirstline < ertcontlastline:
# Multiline ERT. Might contain TeX code. Embrace in ERT.
document.body[parend : parend + 1] = [
- document.body[parend], '\\end_layout', '', '\\end_inset']
+ document.body[parend], '\\end_inset', '', '\\end_layout']
document.body[parbeg : parbeg + 1] = ['\\begin_inset Argument 2',
'status collapsed', '', '\\begin_layout Plain Layout',
'\\begin_inset ERT', '']
else:
# Convert to ArgInset
document.body[parbeg] = "\\begin_inset Argument 2"
+ # the overlay argument can also follow the title, so ...
+ elif document.body[ertcontlastline].rstrip().endswith(">"):
+ # strip off the {
+ document.body[ertcontfirstline] = document.body[ertcontfirstline].lstrip()[1:]
+ # strip off the >
+ document.body[ertcontlastline] = document.body[ertcontlastline].rstrip()[:-1]
+ # divide the args
+ ertcontdivline = ertcontfirstline
+ tok = document.body[ertcontdivline].find('}<')
+ if tok == -1:
+ regexp = re.compile(r'.*\}<', re.IGNORECASE)
+ ertcontdivline = find_re(document.body, regexp, ertcontfirstline, lastertend)
+ tok = document.body[ertcontdivline].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']
+ 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',
+ 'status collapsed', '', '\\begin_layout Plain Layout',
+ document.body[ertcontdivline][tok + 2:]]
+ else:
+ # check if have delimiters in two different ERTs
+ tok = document.body[ertcontdivline].find('}')
+ if tok == -1:
+ regexp = re.compile(r'.*\}', re.IGNORECASE)
+ ertcontdivline = find_re(document.body, regexp, ertcontfirstline, lastertend)
+ tok = document.body[ertcontdivline].find('}')
+ if tok != -1:
+ tokk = document.body[ertcontdivline].find('<')
+ if tokk == -1:
+ regexp = re.compile(r'.*<', re.IGNORECASE)
+ ertcontdivlinetwo = find_re(document.body, regexp, ertcontfirstline, lastertend)
+ tokk = document.body[ertcontdivlinetwo].find('<')
+ if tokk != -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 : ertcontdivlinetwo + 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[ertcontdivlinetwo][tokk + 1:]]
+ else:
+ document.body[ertcontdivline : ertcontdivlinetwo + 1] = [document.body[ertcontdivline][:tok],
+ '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 1',
+ 'status collapsed', '', '\\begin_layout Plain Layout',
+ document.body[ertcontdivlinetwo][tokk + 1:]]
+ # Convert to ArgInset
+ if ertcontfirstline < ertcontlastline:
+ # Multiline ERT. Might contain TeX code. Embrace in ERT.
+ document.body[parbeg : parbeg + 1] = ['\\begin_inset Argument 2',
+ 'status collapsed', '', '\\begin_layout Plain Layout',
+ '\\begin_inset ERT', '']
+ else:
+ document.body[parbeg] = "\\begin_inset Argument 2"
elif count_pars_in_inset(document.body, ertcontfirstline) > 1:
# Multipar ERT. Skip this.
break
else:
- convert_TeX_brace_to_Argument(document, i, 2, 2, False, True, False)
+ # ERT has contents after the closing bracket. We cannot convert this.
+ # convert_TeX_brace_to_Argument cannot either.
+ #convert_TeX_brace_to_Argument(document, i, 2, 2, False, True, False)
+ break
else:
break
j = find_end_of_layout(document.body, i)
continue
endseq = j
subst = ["\\begin_layout Standard"] + put_cmd_in_ert("\\begin{overprint}")
- esubst = ["\\end_layout", "", "\\begin_layout Standard"] + put_cmd_in_ert("\\end{overprint}")
+ esubst = ["\\begin_layout Standard"] + put_cmd_in_ert("\\end{overprint}")
endseq = endseq + len(esubst) - len(document.body[j : j])
if document.body[j] == "\\end_deeper":
- document.body[j : j] = ["\\end_deeper", ""] + esubst
+ document.body[j : j] = [""] + esubst + ["", "\\end_layout"]
else:
- document.body[j : j] = esubst
+ document.body[j : j] = ["\\end_layout", ""] + esubst
r = i
while r < j:
if document.body[r] == "\\begin_deeper":
r = r + 1
argbeg = find_token(document.body, "\\begin_inset Argument 1", i, j)
if argbeg != -1:
- argend = find_end_of_inset(document.body, argbeg)
- if argend == -1:
- document.warning("Malformed LyX document. Cannot find end of Overprint argument!")
- i += 1
- continue
- beginPlain = find_token(document.body, "\\begin_layout Plain Layout", argbeg)
- endPlain = find_end_of_layout(document.body, beginPlain)
- content = document.body[beginPlain + 1 : endPlain]
- # Adjust range end
- endseq = endseq - len(document.body[argbeg : argend])
- # Remove arg inset
- del document.body[argbeg : argend + 1]
- subst += put_cmd_in_ert("[") + content + put_cmd_in_ert("]")
+ # Is this really our argument?
+ nested = find_token(document.body, "\\begin_deeper", i, argbeg)
+ if nested != -1:
+ argend = find_end_of_inset(document.body, argbeg)
+ if argend == -1:
+ document.warning("Malformed LyX document. Cannot find end of Overprint argument!")
+ i += 1
+ continue
+ beginPlain = find_token(document.body, "\\begin_layout Plain Layout", argbeg)
+ endPlain = find_end_of_layout(document.body, beginPlain)
+ content = document.body[beginPlain + 1 : endPlain]
+ # Adjust range end
+ endseq = endseq - len(document.body[argbeg : argend])
+ # 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"]
if i == -1:
return
val = get_value(document.body, "\\begin_layout", i)
- if val in caption_dict.keys():
+ if val in list(caption_dict.keys()):
j = find_end_of_layout(document.body, i)
if j == -1:
document.warning("Malformed LyX document: Missing `\\end_layout'.")
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
continue
endseq = j
subst = ["\\begin_layout Standard"] + put_cmd_in_ert("\\begin{frame}")
- esubst = ["\\end_layout", "", "\\begin_layout Standard"] + put_cmd_in_ert("\\end{frame}")
+ esubst = ["\\begin_layout Standard"] + put_cmd_in_ert("\\end{frame}")
endseq = endseq + len(esubst) - len(document.body[j : j])
if document.body[j] == "\\end_deeper":
- document.body[j : j] = ["\\end_deeper", ""] + esubst
+ document.body[j : j] = [""] + esubst + ["", "\\end_layout"]
else:
document.body[j : j] = esubst
for q in range(i, j):
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
continue
endseq = j
subst = ["\\begin_layout %s" % frame_dict[val]]
- esubst = ["\\end_layout", "", "\\begin_layout EndFrame", "", "\\end_layout"]
+ esubst = ["", "\\begin_layout EndFrame", "", "\\end_layout"]
endseq = endseq + len(esubst) - len(document.body[j : j])
if document.body[j] == "\\end_deeper":
- document.body[j : j] = ["\\end_deeper", ""] + esubst
- else:
document.body[j : j] = esubst
+ else:
+ document.body[j+1 : j+1] = esubst
for q in range(i, j):
if document.body[q] == "\\begin_layout %s" % val:
document.body[q] = "\\begin_layout %s" % document.default_layout
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)
# 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
i += 1
continue
BeginLayout = find_token(document.body, "\\begin_layout Plain Layout", j)
- EndLayout = find_token(document.body, "\\end_layout", BeginLayout)
+ EndLayout = find_end_of_layout(document.body, BeginLayout)
# replace if width is ""
if (width == '""'):
document.body[EndLayout:k + 1] = put_cmd_in_ert("}")
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 == "@":
# 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", ""])
[437, []],
[438, []],
[439, []],
- [440, []],
+ [440, [convert_mathfonts]],
[441, [convert_mdnomath]],
[442, []],
[443, []],
[471, [convert_cite_engine_type_default]],
[472, []],
[473, []],
- [474, [convert_chunks]],
+ [474, [convert_chunks, cleanup_beamerargs]],
]
revert = [