mirror of
https://git.lyx.org/repos/lyx.git
synced 2024-11-09 18:31:04 +00:00
3077 lines
128 KiB
Python
3077 lines
128 KiB
Python
# -*- 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
|
|
# modify it under the terms of the GNU General Public License
|
|
# as published by the Free Software Foundation; either version 2
|
|
# of the License, or (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
""" Convert files to the file format generated by lyx 2.1"""
|
|
|
|
import re, string
|
|
import unicodedata
|
|
import sys, os
|
|
|
|
# Uncomment only what you need to import, please.
|
|
|
|
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
|
|
|
|
#from parser_tools import find_token, find_end_of, find_tokens, \
|
|
#find_end_of_inset, find_end_of_layout, \
|
|
#is_in_inset, del_token, check_token
|
|
|
|
from lyx2lyx_tools import add_to_preamble, put_cmd_in_ert, get_ert
|
|
|
|
#from lyx2lyx_tools import insert_to_preamble, \
|
|
# lyx2latex, latex_length, revert_flex_inset, \
|
|
# revert_font_attrs, hex2ratio, str2bool
|
|
|
|
####################################################################
|
|
# Private helper functions
|
|
|
|
#def remove_option(lines, m, option):
|
|
#''' removes option from line m. returns whether we did anything '''
|
|
#l = lines[m].find(option)
|
|
#if l == -1:
|
|
#return False
|
|
#val = lines[m][l:].split('"')[1]
|
|
#lines[m] = lines[m][:l - 1] + lines[m][l+len(option + '="' + val + '"'):]
|
|
#return True
|
|
|
|
|
|
###############################################################################
|
|
###
|
|
### Conversion and reversion routines
|
|
###
|
|
###############################################################################
|
|
|
|
def revert_visible_space(document):
|
|
"Revert InsetSpace visible into its ERT counterpart"
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, "\\begin_inset space \\textvisiblespace{}", i)
|
|
if i == -1:
|
|
return
|
|
end = find_end_of_inset(document.body, i)
|
|
subst = put_cmd_in_ert("\\textvisiblespace{}")
|
|
document.body[i:end + 1] = subst
|
|
|
|
|
|
def convert_undertilde(document):
|
|
" Load undertilde automatically "
|
|
i = find_token(document.header, "\\use_mathdots" , 0)
|
|
if i == -1:
|
|
i = find_token(document.header, "\\use_mhchem" , 0)
|
|
if i == -1:
|
|
i = find_token(document.header, "\\use_esint" , 0)
|
|
if i == -1:
|
|
document.warning("Malformed LyX document: Can't find \\use_mathdots.")
|
|
return;
|
|
j = find_token(document.preamble, "\\usepackage{undertilde}", 0)
|
|
if j == -1:
|
|
document.header.insert(i + 1, "\\use_undertilde 0")
|
|
else:
|
|
document.header.insert(i + 1, "\\use_undertilde 2")
|
|
del document.preamble[j]
|
|
|
|
|
|
def revert_undertilde(document):
|
|
" Load undertilde if used in the document "
|
|
undertilde = find_token(document.header, "\\use_undertilde" , 0)
|
|
if undertilde == -1:
|
|
document.warning("No \\use_undertilde line. Assuming auto.")
|
|
else:
|
|
val = get_value(document.header, "\\use_undertilde", undertilde)
|
|
del document.header[undertilde]
|
|
try:
|
|
usetilde = int(val)
|
|
except:
|
|
document.warning("Invalid \\use_undertilde value: " + val + ". Assuming auto.")
|
|
# probably usedots has not been changed, but be safe.
|
|
usetilde = 1
|
|
|
|
if usetilde == 0:
|
|
# do not load case
|
|
return
|
|
if usetilde == 2:
|
|
# force load case
|
|
add_to_preamble(document, ["\\usepackage{undertilde}"])
|
|
return
|
|
|
|
# so we are in the auto case. we want to load undertilde if \utilde is used.
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, '\\begin_inset Formula', 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 Formula inset at line " + str(i))
|
|
i += 1
|
|
continue
|
|
code = "\n".join(document.body[i:j])
|
|
if code.find("\\utilde") != -1:
|
|
add_to_preamble(document, ["\\@ifundefined{utilde}{\\usepackage{undertilde}}"])
|
|
return
|
|
i = j
|
|
|
|
|
|
def revert_negative_space(document):
|
|
"Revert InsetSpace negmedspace and negthickspace into its TeX-code counterpart"
|
|
i = 0
|
|
j = 0
|
|
reverted = False
|
|
while True:
|
|
i = find_token(document.body, "\\begin_inset space \\negmedspace{}", i)
|
|
if i == -1:
|
|
j = find_token(document.body, "\\begin_inset space \\negthickspace{}", j)
|
|
if j == -1:
|
|
# load amsmath in the preamble if not already loaded if we are at the end of checking
|
|
if reverted == True:
|
|
i = find_token(document.header, "\\use_amsmath 2", 0)
|
|
if i == -1:
|
|
add_to_preamble(document, ["\\@ifundefined{negthickspace}{\\usepackage{amsmath}}"])
|
|
return
|
|
if i == -1:
|
|
return
|
|
end = find_end_of_inset(document.body, i)
|
|
subst = put_cmd_in_ert("\\negmedspace{}")
|
|
document.body[i:end + 1] = subst
|
|
j = find_token(document.body, "\\begin_inset space \\negthickspace{}", j)
|
|
if j == -1:
|
|
return
|
|
end = find_end_of_inset(document.body, j)
|
|
subst = put_cmd_in_ert("\\negthickspace{}")
|
|
document.body[j:end + 1] = subst
|
|
reverted = True
|
|
|
|
|
|
def revert_math_spaces(document):
|
|
"Revert formulas with protected custom space and protected hfills to TeX-code"
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, "\\begin_inset Formula", i)
|
|
if i == -1:
|
|
return
|
|
j = document.body[i].find("\\hspace*")
|
|
if j != -1:
|
|
end = find_end_of_inset(document.body, i)
|
|
subst = put_cmd_in_ert(document.body[i][21:])
|
|
document.body[i:end + 1] = subst
|
|
i = i + 1
|
|
|
|
|
|
def convert_japanese_encodings(document):
|
|
" Rename the japanese encodings to names understood by platex "
|
|
jap_enc_dict = {
|
|
"EUC-JP-pLaTeX": "euc",
|
|
"JIS-pLaTeX": "jis",
|
|
"SJIS-pLaTeX": "sjis"
|
|
}
|
|
i = find_token(document.header, "\\inputencoding" , 0)
|
|
if i == -1:
|
|
return
|
|
val = get_value(document.header, "\\inputencoding", i)
|
|
if val in jap_enc_dict.keys():
|
|
document.header[i] = "\\inputencoding %s" % jap_enc_dict[val]
|
|
|
|
|
|
def revert_japanese_encodings(document):
|
|
" Revert the japanese encodings name changes "
|
|
jap_enc_dict = {
|
|
"euc": "EUC-JP-pLaTeX",
|
|
"jis": "JIS-pLaTeX",
|
|
"sjis": "SJIS-pLaTeX"
|
|
}
|
|
i = find_token(document.header, "\\inputencoding" , 0)
|
|
if i == -1:
|
|
return
|
|
val = get_value(document.header, "\\inputencoding", i)
|
|
if val in jap_enc_dict.keys():
|
|
document.header[i] = "\\inputencoding %s" % jap_enc_dict[val]
|
|
|
|
|
|
def revert_justification(document):
|
|
" Revert the \\justification buffer param"
|
|
if not del_token(document.header, '\\justification', 0):
|
|
document.warning("Malformed LyX document: Missing \\justification.")
|
|
|
|
|
|
def revert_australian(document):
|
|
"Set English language variants Australian and Newzealand to English"
|
|
|
|
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)
|
|
if j == -1:
|
|
j = find_token(document.body, "\\lang newzealand", 0)
|
|
if j == -1:
|
|
return
|
|
else:
|
|
document.body[j] = document.body[j].replace("\\lang newzealand", "\\lang english")
|
|
else:
|
|
document.body[j] = document.body[j].replace("\\lang australian", "\\lang english")
|
|
j += 1
|
|
|
|
|
|
def convert_biblio_style(document):
|
|
"Add a sensible default for \\biblio_style based on the citation engine."
|
|
i = find_token(document.header, "\\cite_engine", 0)
|
|
if i != -1:
|
|
engine = get_value(document.header, "\\cite_engine", i).split("_")[0]
|
|
style = {"basic": "plain", "natbib": "plainnat", "jurabib": "jurabib"}
|
|
document.header.insert(i + 1, "\\biblio_style " + style[engine])
|
|
|
|
|
|
def revert_biblio_style(document):
|
|
"BibTeX insets with default option use the style defined by \\biblio_style."
|
|
i = find_token(document.header, "\\biblio_style" , 0)
|
|
if i == -1:
|
|
document.warning("No \\biblio_style line. Nothing to do.")
|
|
return
|
|
|
|
default_style = get_value(document.header, "\\biblio_style", i)
|
|
del document.header[i]
|
|
|
|
# We are looking for bibtex insets having the default option
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, "\\begin_inset CommandInset bibtex", 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 bibtex inset at line " + str(i))
|
|
i += 1
|
|
return
|
|
k = find_token(document.body, "options", i, j)
|
|
if k != -1:
|
|
options = get_quoted_value(document.body, "options", k)
|
|
if "default" in options.split(","):
|
|
document.body[k] = 'options "%s"' \
|
|
% options.replace("default", default_style)
|
|
i = j
|
|
|
|
|
|
def handle_longtable_captions(document, forward):
|
|
begin_table = 0
|
|
while True:
|
|
begin_table = find_token(document.body, '<lyxtabular version=', begin_table)
|
|
if begin_table == -1:
|
|
break
|
|
end_table = find_end_of(document.body, begin_table, '<lyxtabular', '</lyxtabular>')
|
|
if end_table == -1:
|
|
document.warning("Malformed LyX document: Could not find end of table.")
|
|
begin_table += 1
|
|
continue
|
|
fline = find_token(document.body, "<features", begin_table, end_table)
|
|
if fline == -1:
|
|
document.warning("Can't find features for inset at line " + str(begin_table))
|
|
begin_table += 1
|
|
continue
|
|
p = document.body[fline].find("islongtable")
|
|
if p == -1:
|
|
# no longtable
|
|
begin_table += 1
|
|
continue
|
|
numrows = get_option_value(document.body[begin_table], "rows")
|
|
try:
|
|
numrows = int(numrows)
|
|
except:
|
|
document.warning(document.body[begin_table])
|
|
document.warning("Unable to determine rows!")
|
|
begin_table = end_table
|
|
continue
|
|
begin_row = begin_table
|
|
for row in range(numrows):
|
|
begin_row = find_token(document.body, '<row', begin_row, end_table)
|
|
if begin_row == -1:
|
|
document.warning("Can't find row " + str(row + 1))
|
|
break
|
|
end_row = find_end_of(document.body, begin_row, '<row', '</row>')
|
|
if end_row == -1:
|
|
document.warning("Can't find end of row " + str(row + 1))
|
|
break
|
|
if forward:
|
|
if (get_option_value(document.body[begin_row], 'caption') == 'true' and
|
|
get_option_value(document.body[begin_row], 'endfirsthead') != 'true' and
|
|
get_option_value(document.body[begin_row], 'endhead') != 'true' and
|
|
get_option_value(document.body[begin_row], 'endfoot') != 'true' and
|
|
get_option_value(document.body[begin_row], 'endlastfoot') != 'true'):
|
|
document.body[begin_row] = set_option_value(document.body[begin_row], 'caption', 'true", endfirsthead="true')
|
|
elif get_option_value(document.body[begin_row], 'caption') == 'true':
|
|
if get_option_value(document.body[begin_row], 'endfirsthead') == 'true':
|
|
document.body[begin_row] = set_option_value(document.body[begin_row], 'endfirsthead', 'false')
|
|
if get_option_value(document.body[begin_row], 'endhead') == 'true':
|
|
document.body[begin_row] = set_option_value(document.body[begin_row], 'endhead', 'false')
|
|
if get_option_value(document.body[begin_row], 'endfoot') == 'true':
|
|
document.body[begin_row] = set_option_value(document.body[begin_row], 'endfoot', 'false')
|
|
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
|
|
# cannot jump to end.
|
|
begin_table += 1
|
|
|
|
|
|
def convert_longtable_captions(document):
|
|
"Add a firsthead flag to caption rows"
|
|
handle_longtable_captions(document, True)
|
|
|
|
|
|
def revert_longtable_captions(document):
|
|
"remove head/foot flag from caption rows"
|
|
handle_longtable_captions(document, False)
|
|
|
|
|
|
def convert_use_packages(document):
|
|
"use_xxx yyy => use_package xxx yyy"
|
|
packages = ["amsmath", "esint", "mathdots", "mhchem", "undertilde"]
|
|
for p in packages:
|
|
i = find_token(document.header, "\\use_%s" % p, 0)
|
|
if i != -1:
|
|
value = get_value(document.header, "\\use_%s" % p, i)
|
|
document.header[i] = "\\use_package %s %s" % (p, value)
|
|
|
|
|
|
def revert_use_packages(document):
|
|
"use_package xxx yyy => use_xxx yyy"
|
|
packages = ["amsmath", "esint", "mathdots", "mhchem", "undertilde"]
|
|
# the order is arbitrary for the use_package version, and not all packages need to be given.
|
|
# Ensure a complete list and correct order (important for older LyX versions and especially lyx2lyx)
|
|
j = 0
|
|
for p in packages:
|
|
regexp = re.compile(r'(\\use_package\s+%s)' % p)
|
|
i = find_re(document.header, regexp, j)
|
|
if i != -1:
|
|
value = get_value(document.header, "\\use_package %s" % p, i).split()[1]
|
|
del document.header[i]
|
|
j = i
|
|
document.header.insert(j, "\\use_%s %s" % (p, value))
|
|
j = j + 1
|
|
|
|
|
|
def convert_use_mathtools(document):
|
|
"insert use_package mathtools"
|
|
i = find_token(document.header, "\\use_package", 0)
|
|
if i == -1:
|
|
document.warning("Malformed LyX document: Can't find \\use_package.")
|
|
return;
|
|
j = find_token(document.preamble, "\\usepackage{mathtools}", 0)
|
|
if j == -1:
|
|
document.header.insert(i + 1, "\\use_package mathtools 0")
|
|
else:
|
|
document.header.insert(i + 1, "\\use_package mathtools 2")
|
|
del document.preamble[j]
|
|
|
|
|
|
def revert_use_mathtools(document):
|
|
"remove use_package mathtools"
|
|
regexp = re.compile(r'(\\use_package\s+mathtools)')
|
|
i = find_re(document.header, regexp, 0)
|
|
value = "1" # default is auto
|
|
if i != -1:
|
|
value = get_value(document.header, "\\use_package" , i).split()[1]
|
|
del document.header[i]
|
|
if value == "2": # on
|
|
add_to_preamble(document, ["\\usepackage{mathtools}"])
|
|
elif value == "1": # auto
|
|
commands = ["mathclap", "mathllap", "mathrlap", \
|
|
"lgathered", "rgathered", "vcentcolon", "dblcolon", \
|
|
"coloneqq", "Coloneqq", "coloneq", "Coloneq", "eqqcolon", \
|
|
"Eqqcolon", "eqcolon", "Eqcolon", "colonapprox", \
|
|
"Colonapprox", "colonsim", "Colonsim"]
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, '\\begin_inset Formula', 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 Formula inset at line " + str(i))
|
|
i += 1
|
|
continue
|
|
code = "\n".join(document.body[i:j])
|
|
for c in commands:
|
|
if code.find("\\%s" % c) != -1:
|
|
add_to_preamble(document, ["\\usepackage{mathtools}"])
|
|
return
|
|
i = j
|
|
|
|
|
|
def convert_use_stmaryrd(document):
|
|
"insert use_package stmaryrd"
|
|
i = find_token(document.header, "\\use_package", 0)
|
|
if i == -1:
|
|
document.warning("Malformed LyX document: Can't find \\use_package.")
|
|
return;
|
|
j = find_token(document.preamble, "\\usepackage{stmaryrd}", 0)
|
|
if j == -1:
|
|
document.header.insert(i + 1, "\\use_package stmaryrd 0")
|
|
else:
|
|
document.header.insert(i + 1, "\\use_package stmaryrd 2")
|
|
del document.preamble[j]
|
|
|
|
|
|
def revert_use_stmaryrd(document):
|
|
"remove use_package stmaryrd"
|
|
regexp = re.compile(r'(\\use_package\s+stmaryrd)')
|
|
i = find_re(document.header, regexp, 0)
|
|
value = "1" # default is auto
|
|
if i != -1:
|
|
value = get_value(document.header, "\\use_package" , i).split()[1]
|
|
del document.header[i]
|
|
if value == "2": # on
|
|
add_to_preamble(document, ["\\usepackage{stmaryrd}"])
|
|
elif value == "1": # auto
|
|
commands = ["shortleftarrow", "shortrightarrow", "shortuparrow", \
|
|
"shortdownarrow", "Yup", "Ydown", "Yleft", "Yright", \
|
|
"varcurlyvee", "varcurlywedge", "minuso", "baro", \
|
|
"sslash", "bbslash", "moo", "varotimes", "varoast", \
|
|
"varobar", "varodot", "varoslash", "varobslash", \
|
|
"varocircle", "varoplus", "varominus", "boxast", \
|
|
"boxbar", "boxslash", "boxbslash", "boxcircle", \
|
|
"boxbox", "boxempty", "merge", "vartimes", \
|
|
"fatsemi", "sswarrow", "ssearrow", "curlywedgeuparrow", \
|
|
"curlywedgedownarrow", "fatslash", "fatbslash", "lbag", \
|
|
"rbag", "varbigcirc", "leftrightarroweq", \
|
|
"curlyveedownarrow", "curlyveeuparrow", "nnwarrow", \
|
|
"nnearrow", "leftslice", "rightslice", "varolessthan", \
|
|
"varogreaterthan", "varovee", "varowedge", "talloblong", \
|
|
"interleave", "obar", "obslash", "olessthan", \
|
|
"ogreaterthan", "ovee", "owedge", "oblong", "inplus", \
|
|
"niplus", "nplus", "subsetplus", "supsetplus", \
|
|
"subsetpluseq", "supsetpluseq", "Lbag", "Rbag", \
|
|
"llbracket", "rrbracket", "llparenthesis", \
|
|
"rrparenthesis", "binampersand", "bindnasrepma", \
|
|
"trianglelefteqslant", "trianglerighteqslant", \
|
|
"ntrianglelefteqslant", "ntrianglerighteqslant", \
|
|
"llfloor", "rrfloor", "llceil", "rrceil", "arrownot", \
|
|
"Arrownot", "Mapstochar", "mapsfromchar", "Mapsfromchar", \
|
|
"leftrightarrowtriangle", "leftarrowtriangle", \
|
|
"rightarrowtriangle", \
|
|
"bigcurlyvee", "bigcurlywedge", "bigsqcap", "bigbox", \
|
|
"bigparallel", "biginterleave", "bignplus", \
|
|
"varcopyright", "longarrownot", "Longarrownot", \
|
|
"Mapsto", "mapsfrom", "Mapsfrom" "Longmapsto", \
|
|
"longmapsfrom", "Longmapsfrom"]
|
|
# commands provided by stmaryrd.sty but LyX uses other packages:
|
|
# boxdot lightning, bigtriangledown, bigtriangleup
|
|
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, '\\begin_inset Formula', 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 Formula inset at line " + str(i))
|
|
i += 1
|
|
continue
|
|
code = "\n".join(document.body[i:j])
|
|
for c in commands:
|
|
if code.find("\\%s" % c) != -1:
|
|
add_to_preamble(document, ["\\usepackage{stmaryrd}"])
|
|
return
|
|
i = j
|
|
|
|
|
|
def convert_cite_engine_type(document):
|
|
"Determine the \\cite_engine_type from the citation engine."
|
|
i = find_token(document.header, "\\cite_engine", 0)
|
|
if i == -1:
|
|
return
|
|
engine = get_value(document.header, "\\cite_engine", i)
|
|
if "_" in engine:
|
|
engine, type = engine.split("_")
|
|
else:
|
|
type = {"basic": "numerical", "jurabib": "authoryear"}[engine]
|
|
document.header[i] = "\\cite_engine " + engine
|
|
document.header.insert(i + 1, "\\cite_engine_type " + type)
|
|
|
|
|
|
def revert_cite_engine_type(document):
|
|
"Natbib had the type appended with an underscore."
|
|
engine_type = "numerical"
|
|
i = find_token(document.header, "\\cite_engine_type" , 0)
|
|
if i == -1:
|
|
document.warning("No \\cite_engine_type line. Assuming numerical.")
|
|
else:
|
|
engine_type = get_value(document.header, "\\cite_engine_type", i)
|
|
del document.header[i]
|
|
|
|
# We are looking for the natbib citation engine
|
|
i = find_token(document.header, "\\cite_engine natbib", 0)
|
|
if i == -1:
|
|
return
|
|
document.header[i] = "\\cite_engine natbib_" + engine_type
|
|
|
|
|
|
def revert_cancel(document):
|
|
"add cancel to the preamble if necessary"
|
|
commands = ["cancelto", "cancel", "bcancel", "xcancel"]
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, '\\begin_inset Formula', 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 Formula inset at line " + str(i))
|
|
i += 1
|
|
continue
|
|
code = "\n".join(document.body[i:j])
|
|
for c in commands:
|
|
if code.find("\\%s" % c) != -1:
|
|
add_to_preamble(document, ["\\usepackage{cancel}"])
|
|
return
|
|
i = j
|
|
|
|
|
|
def revert_verbatim(document):
|
|
" Revert verbatim einvironments completely to TeX-code. "
|
|
i = 0
|
|
consecutive = False
|
|
subst_end = ['\end_layout', '', '\\begin_layout Plain Layout',
|
|
'\end_layout', '',
|
|
'\\begin_layout Plain Layout', '', '',
|
|
'\\backslash', '',
|
|
'end{verbatim}',
|
|
'\\end_layout', '', '\\end_inset',
|
|
'', '', '\\end_layout']
|
|
subst_begin = ['\\begin_layout Standard', '\\noindent',
|
|
'\\begin_inset ERT', 'status collapsed', '',
|
|
'\\begin_layout Plain Layout', '', '', '\\backslash',
|
|
'begin{verbatim}',
|
|
'\\end_layout', '', '\\begin_layout Plain Layout', '']
|
|
while 1:
|
|
i = find_token(document.body, "\\begin_layout Verbatim", 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")
|
|
i += 1
|
|
continue
|
|
# delete all line breaks insets (there are no other insets)
|
|
l = i
|
|
while 1:
|
|
n = find_token(document.body, "\\begin_inset Newline newline", l)
|
|
if n == -1:
|
|
n = find_token(document.body, "\\begin_inset Newline linebreak", l)
|
|
if n == -1:
|
|
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']
|
|
l += 1
|
|
j += 1
|
|
# consecutive verbatim environments need to be connected
|
|
k = find_token(document.body, "\\begin_layout Verbatim", j)
|
|
if k == j + 2 and consecutive == False:
|
|
consecutive = True
|
|
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']
|
|
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
|
|
document.body[j+19:j+19] = ['\\noindent']
|
|
del(document.body[i:i+1])
|
|
consecutive = False
|
|
continue
|
|
else:
|
|
document.body[j:j+1] = subst_end
|
|
# the next paragraph must not be indented
|
|
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:
|
|
i = find_token(document.body, "\\begin_inset IPA", 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 IPA inset")
|
|
i += 1
|
|
continue
|
|
Multipar = False
|
|
n = find_token(document.body, "\\begin_layout", i, j)
|
|
if n == -1:
|
|
document.warning("Malformed lyx document: IPA inset has no embedded layout")
|
|
i += 1
|
|
continue
|
|
m = find_end_of_layout(document.body, n)
|
|
if m == -1:
|
|
document.warning("Malformed lyx document: Can't find end of embedded layout")
|
|
i += 1
|
|
continue
|
|
content = document.body[n+1:m]
|
|
p = find_token(document.body, "\\begin_layout", m, j)
|
|
if p != -1 or len(content) > 1:
|
|
Multipar = True
|
|
content = document.body[i+1:j]
|
|
if Multipar:
|
|
# IPA insets with multiple pars need to be wrapped by \begin{IPA}...\end{IPA}
|
|
document.body[i:j+1] = ['\\end_layout', '', '\\begin_layout Standard'] + put_cmd_in_ert("\\begin{IPA}") + ['\\end_layout'] + content + ['\\begin_layout Standard'] + put_cmd_in_ert("\\end{IPA}")
|
|
add_to_preamble(document, ["\\usepackage{tipa,tipx}"])
|
|
else:
|
|
# single-par IPA insets can be reverted to mathed
|
|
document.body[i:j+1] = ["\\begin_inset Formula $\\text{\\textipa{" + content[0] + "}}$", "\\end_inset"]
|
|
i = j
|
|
|
|
|
|
def revert_cell_rotation(document):
|
|
"Revert cell rotations to TeX-code"
|
|
|
|
load_rotating = False
|
|
i = 0
|
|
try:
|
|
while True:
|
|
# first, let's find out if we need to do anything
|
|
i = find_token(document.body, '<cell ', i)
|
|
if i == -1:
|
|
return
|
|
j = document.body[i].find('rotate="')
|
|
if j != -1:
|
|
k = document.body[i].find('"', j + 8)
|
|
value = document.body[i][j + 8 : k]
|
|
if value == "0":
|
|
rgx = re.compile(r' rotate="[^"]+?"')
|
|
# remove rotate option
|
|
document.body[i] = rgx.sub('', document.body[i])
|
|
elif value == "90":
|
|
rgx = re.compile(r' rotate="[^"]+?"')
|
|
document.body[i] = rgx.sub('rotate="true"', document.body[i])
|
|
else:
|
|
rgx = re.compile(r' rotate="[^"]+?"')
|
|
load_rotating = True
|
|
# remove rotate option
|
|
document.body[i] = rgx.sub('', document.body[i])
|
|
# write ERT
|
|
document.body[i + 5 : i + 5] = \
|
|
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}}{}"])
|
|
|
|
|
|
def convert_cell_rotation(document):
|
|
'Convert cell rotation statements from "true" to "90"'
|
|
|
|
i = 0
|
|
while True:
|
|
# first, let's find out if we need to do anything
|
|
i = find_token(document.body, '<cell ', i)
|
|
if i == -1:
|
|
return
|
|
j = document.body[i].find('rotate="true"')
|
|
if j != -1:
|
|
rgx = re.compile(r'rotate="[^"]+?"')
|
|
# convert "true" to "90"
|
|
document.body[i] = rgx.sub('rotate="90"', document.body[i])
|
|
|
|
i += 1
|
|
|
|
|
|
def revert_table_rotation(document):
|
|
"Revert table rotations to TeX-code"
|
|
|
|
load_rotating = False
|
|
i = 0
|
|
try:
|
|
while True:
|
|
# first, let's find out if we need to do anything
|
|
i = find_token(document.body, '<features ', i)
|
|
if i == -1:
|
|
return
|
|
j = document.body[i].find('rotate="')
|
|
if j != -1:
|
|
end_table = find_token(document.body, '</lyxtabular>', j)
|
|
k = document.body[i].find('"', j + 8)
|
|
value = document.body[i][j + 8 : k]
|
|
if value == "0":
|
|
rgx = re.compile(r' rotate="[^"]+?"')
|
|
# remove rotate option
|
|
document.body[i] = rgx.sub('', document.body[i])
|
|
elif value == "90":
|
|
rgx = re.compile(r'rotate="[^"]+?"')
|
|
document.body[i] = rgx.sub('rotate="true"', document.body[i])
|
|
else:
|
|
rgx = re.compile(r' rotate="[^"]+?"')
|
|
load_rotating = True
|
|
# remove rotate option
|
|
document.body[i] = rgx.sub('', document.body[i])
|
|
# write ERT
|
|
document.body[end_table + 3 : end_table + 3] = \
|
|
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}}{}"])
|
|
|
|
|
|
def convert_table_rotation(document):
|
|
'Convert table rotation statements from "true" to "90"'
|
|
|
|
i = 0
|
|
while True:
|
|
# first, let's find out if we need to do anything
|
|
i = find_token(document.body, '<features ', i)
|
|
if i == -1:
|
|
return
|
|
j = document.body[i].find('rotate="true"')
|
|
if j != -1:
|
|
rgx = re.compile(r'rotate="[^"]+?"')
|
|
# convert "true" to "90"
|
|
document.body[i] = rgx.sub('rotate="90"', document.body[i])
|
|
|
|
i += 1
|
|
|
|
|
|
def convert_listoflistings(document):
|
|
'Convert ERT \lstlistoflistings to TOC lstlistoflistings inset'
|
|
# We can support roundtrip because the command is so simple
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, "\\begin_inset ERT", 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 ERT inset")
|
|
i += 1
|
|
continue
|
|
ert = get_ert(document.body, i)
|
|
if ert == "\\lstlistoflistings{}":
|
|
document.body[i:j] = ["\\begin_inset CommandInset toc", "LatexCommand lstlistoflistings", ""]
|
|
i = i + 4
|
|
else:
|
|
i = j + 1
|
|
|
|
|
|
def revert_listoflistings(document):
|
|
'Convert TOC lstlistoflistings inset to ERT lstlistoflistings'
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, "\\begin_inset CommandInset toc", i)
|
|
if i == -1:
|
|
return
|
|
if document.body[i+1] == "LatexCommand lstlistoflistings":
|
|
j = find_end_of_inset(document.body, i)
|
|
if j == -1:
|
|
document.warning("Malformed lyx document: Can't find end of TOC inset")
|
|
i += 1
|
|
continue
|
|
subst = put_cmd_in_ert("\\lstlistoflistings{}")
|
|
document.body[i:j+1] = subst
|
|
add_to_preamble(document, ["\\usepackage{listings}"])
|
|
i = i + 1
|
|
|
|
|
|
def convert_use_amssymb(document):
|
|
"insert use_package amssymb"
|
|
regexp = re.compile(r'(\\use_package\s+amsmath)')
|
|
i = find_re(document.header, regexp, 0)
|
|
if i == -1:
|
|
document.warning("Malformed LyX document: Can't find \\use_package amsmath.")
|
|
return;
|
|
value = get_value(document.header, "\\use_package" , i).split()[1]
|
|
useamsmath = 0
|
|
try:
|
|
useamsmath = int(value)
|
|
except:
|
|
document.warning("Invalid \\use_package amsmath: " + value + ". Assuming auto.")
|
|
useamsmath = 1
|
|
j = find_token(document.preamble, "\\usepackage{amssymb}", 0)
|
|
if j == -1:
|
|
document.header.insert(i + 1, "\\use_package amssymb %d" % useamsmath)
|
|
else:
|
|
document.header.insert(i + 1, "\\use_package amssymb 2")
|
|
del document.preamble[j]
|
|
|
|
|
|
def revert_use_amssymb(document):
|
|
"remove use_package amssymb"
|
|
regexp1 = re.compile(r'(\\use_package\s+amsmath)')
|
|
regexp2 = re.compile(r'(\\use_package\s+amssymb)')
|
|
i = find_re(document.header, regexp1, 0)
|
|
j = find_re(document.header, regexp2, 0)
|
|
value1 = "1" # default is auto
|
|
value2 = "1" # default is auto
|
|
if i != -1:
|
|
value1 = get_value(document.header, "\\use_package" , i).split()[1]
|
|
if j != -1:
|
|
value2 = get_value(document.header, "\\use_package" , j).split()[1]
|
|
del document.header[j]
|
|
if value1 != value2 and value2 == "2": # on
|
|
add_to_preamble(document, ["\\usepackage{amssymb}"])
|
|
|
|
|
|
def revert_ancientgreek(document):
|
|
"Set the document language for ancientgreek to greek"
|
|
|
|
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)
|
|
if j == -1:
|
|
return
|
|
else:
|
|
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"
|
|
|
|
languages = [
|
|
"coptic", "divehi", "hindi", "kurmanji", "lao", "marathi", "occitan", "sanskrit",
|
|
"syriac", "tamil", "telugu", "urdu"
|
|
]
|
|
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"
|
|
j = 0
|
|
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")
|
|
j += 1
|
|
else:
|
|
j = len(document.body)
|
|
|
|
|
|
def convert_armenian(document):
|
|
"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"
|
|
|
|
|
|
def revert_armenian(document):
|
|
"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"
|
|
|
|
|
|
def revert_libertine(document):
|
|
" Revert native libertine font definition to LaTeX "
|
|
|
|
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
|
|
j = find_token(document.header, "\\font_osf true", 0)
|
|
if j != -1:
|
|
osf = True
|
|
preamble = "\\usepackage"
|
|
if osf:
|
|
document.header[j] = "\\font_osf false"
|
|
else:
|
|
preamble += "[lining]"
|
|
preamble += "{libertine-type1}"
|
|
add_to_preamble(document, [preamble])
|
|
document.header[i] = "\\font_roman default"
|
|
|
|
|
|
def revert_txtt(document):
|
|
" Revert native txtt font definition to LaTeX "
|
|
|
|
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}"
|
|
add_to_preamble(document, [preamble])
|
|
document.header[i] = "\\font_typewriter default"
|
|
|
|
|
|
def revert_mathdesign(document):
|
|
" Revert native mathdesign font definition to LaTeX "
|
|
|
|
if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
|
|
mathdesign_dict = {
|
|
"mdbch": "charter",
|
|
"mdput": "utopia",
|
|
"mdugm": "garamond"
|
|
}
|
|
i = find_token(document.header, "\\font_roman", 0)
|
|
if i == -1:
|
|
return
|
|
val = get_value(document.header, "\\font_roman", i)
|
|
if val in mathdesign_dict.keys():
|
|
preamble = "\\usepackage[%s" % mathdesign_dict[val]
|
|
expert = False
|
|
j = find_token(document.header, "\\font_osf true", 0)
|
|
if j != -1:
|
|
expert = True
|
|
document.header[j] = "\\font_osf false"
|
|
l = find_token(document.header, "\\font_sc true", 0)
|
|
if l != -1:
|
|
expert = True
|
|
document.header[l] = "\\font_sc false"
|
|
if expert:
|
|
preamble += ",expert"
|
|
preamble += "]{mathdesign}"
|
|
add_to_preamble(document, [preamble])
|
|
document.header[i] = "\\font_roman default"
|
|
|
|
|
|
def revert_texgyre(document):
|
|
" Revert native TeXGyre font definition to LaTeX "
|
|
|
|
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)
|
|
if i != -1:
|
|
val = get_value(document.header, "\\font_roman", i)
|
|
if val in texgyre_fonts:
|
|
preamble = "\\usepackage{%s}" % val
|
|
add_to_preamble(document, [preamble])
|
|
document.header[i] = "\\font_roman default"
|
|
i = find_token(document.header, "\\font_sans", 0)
|
|
if i != -1:
|
|
val = get_value(document.header, "\\font_sans", i)
|
|
if val in texgyre_fonts:
|
|
preamble = "\\usepackage{%s}" % val
|
|
add_to_preamble(document, [preamble])
|
|
document.header[i] = "\\font_sans default"
|
|
i = find_token(document.header, "\\font_typewriter", 0)
|
|
if i != -1:
|
|
val = get_value(document.header, "\\font_typewriter", i)
|
|
if val in texgyre_fonts:
|
|
preamble = "\\usepackage{%s}" % val
|
|
add_to_preamble(document, [preamble])
|
|
document.header[i] = "\\font_typewriter default"
|
|
|
|
|
|
def revert_ipadeco(document):
|
|
" Revert IPA decorations to ERT "
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, "\\begin_inset IPADeco", i)
|
|
if i == -1:
|
|
return
|
|
end = find_end_of_inset(document.body, i)
|
|
if end == -1:
|
|
document.warning("Can't find end of inset at line " + str(i))
|
|
i += 1
|
|
continue
|
|
line = document.body[i]
|
|
rx = re.compile(r'\\begin_inset IPADeco (.*)$')
|
|
m = rx.match(line)
|
|
decotype = m.group(1)
|
|
if decotype != "toptiebar" and decotype != "bottomtiebar":
|
|
document.warning("Invalid IPADeco type: " + decotype)
|
|
i = end
|
|
continue
|
|
blay = find_token(document.body, "\\begin_layout Plain Layout", i, end)
|
|
if blay == -1:
|
|
document.warning("Can't find layout for inset at line " + str(i))
|
|
i = end
|
|
continue
|
|
bend = find_end_of_layout(document.body, blay)
|
|
if bend == -1:
|
|
document.warning("Malformed LyX document: Could not find end of IPADeco inset's layout.")
|
|
i = end
|
|
continue
|
|
substi = ["\\begin_inset ERT", "status collapsed", "",
|
|
"\\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"]
|
|
# do the later one first so as not to mess up the numbering
|
|
document.body[bend:end + 1] = substj
|
|
document.body[i:blay + 1] = substi
|
|
i = end + len(substi) + len(substj) - (end - bend) - (blay - i) - 2
|
|
add_to_preamble(document, "\\usepackage{tipa}")
|
|
|
|
|
|
def revert_ipachar(document):
|
|
' Revert \\IPAChar to ERT '
|
|
i = 0
|
|
found = False
|
|
while i < len(document.body):
|
|
m = re.match(r'(.*)\\IPAChar \\(\w+\{\w+\})(.*)', document.body[i])
|
|
if m:
|
|
found = True
|
|
before = m.group(1)
|
|
ipachar = m.group(2)
|
|
after = m.group(3)
|
|
subst = [before,
|
|
'\\begin_inset ERT',
|
|
'status collapsed', '',
|
|
'\\begin_layout Standard',
|
|
'', '', '\\backslash',
|
|
ipachar,
|
|
'\\end_layout', '',
|
|
'\\end_inset', '',
|
|
after]
|
|
document.body[i: i+1] = subst
|
|
i = i + len(subst)
|
|
else:
|
|
i = i + 1
|
|
if found:
|
|
add_to_preamble(document, "\\usepackage{tone}")
|
|
|
|
|
|
def revert_minionpro(document):
|
|
" Revert native MinionPro font definition to LaTeX "
|
|
|
|
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
|
|
j = find_token(document.header, "\\font_osf true", 0)
|
|
if j != -1:
|
|
osf = True
|
|
preamble = "\\usepackage"
|
|
if osf:
|
|
document.header[j] = "\\font_osf false"
|
|
else:
|
|
preamble += "[lf]"
|
|
preamble += "{MinionPro}"
|
|
add_to_preamble(document, [preamble])
|
|
document.header[i] = "\\font_roman default"
|
|
|
|
|
|
def revert_mathfonts(document):
|
|
" 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:
|
|
val = get_value(document.header, "\\font_math", i)
|
|
if val == "eulervm":
|
|
add_to_preamble(document, "\\usepackage{eulervm}")
|
|
elif val == "default":
|
|
mathfont_dict = {
|
|
"lmodern": "\\renewcommand{\\rmdefault}{lmr}",
|
|
"minionpro": "\\usepackage[onlytext,lf]{MinionPro}",
|
|
"minionpro-osf": "\\usepackage[onlytext]{MinionPro}",
|
|
"palatino": "\\renewcommand{\\rmdefault}{ppl}",
|
|
"palatino-osf": "\\renewcommand{\\rmdefault}{pplj}",
|
|
"times": "\\renewcommand{\\rmdefault}{ptm}",
|
|
"utopia": "\\renewcommand{\\rmdefault}{futs}",
|
|
"utopia-osf": "\\renewcommand{\\rmdefault}{futj}",
|
|
}
|
|
j = find_token(document.header, "\\font_roman", 0)
|
|
if j != -1:
|
|
rm = get_value(document.header, "\\font_roman", j)
|
|
k = find_token(document.header, "\\font_osf true", 0)
|
|
if k != -1:
|
|
rm += "-osf"
|
|
if rm in mathfont_dict.keys():
|
|
add_to_preamble(document, mathfont_dict[rm])
|
|
document.header[j] = "\\font_roman default"
|
|
if k != -1:
|
|
document.header[k] = "\\font_osf false"
|
|
del document.header[i]
|
|
|
|
|
|
def revert_mdnomath(document):
|
|
" Revert mathdesign and fourier without math "
|
|
|
|
if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
|
|
mathdesign_dict = {
|
|
"md-charter": "mdbch",
|
|
"md-utopia": "mdput",
|
|
"md-garamond": "mdugm"
|
|
}
|
|
i = find_token(document.header, "\\font_roman", 0)
|
|
if i == -1:
|
|
return
|
|
val = get_value(document.header, "\\font_roman", i)
|
|
if val in mathdesign_dict.keys():
|
|
j = find_token(document.header, "\\font_math", 0)
|
|
if j == -1:
|
|
document.header[i] = "\\font_roman %s" % mathdesign_dict[val]
|
|
mval = get_value(document.header, "\\font_math", j)
|
|
if mval == "default":
|
|
document.header[i] = "\\font_roman default"
|
|
add_to_preamble(document, "\\renewcommand{\\rmdefault}{%s}" % mathdesign_dict[val])
|
|
else:
|
|
document.header[i] = "\\font_roman %s" % mathdesign_dict[val]
|
|
|
|
|
|
def convert_mdnomath(document):
|
|
" Change mathdesign font name "
|
|
|
|
if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
|
|
mathdesign_dict = {
|
|
"mdbch": "md-charter",
|
|
"mdput": "md-utopia",
|
|
"mdugm": "md-garamond"
|
|
}
|
|
i = find_token(document.header, "\\font_roman", 0)
|
|
if i == -1:
|
|
return
|
|
val = get_value(document.header, "\\font_roman", i)
|
|
if val in mathdesign_dict.keys():
|
|
document.header[i] = "\\font_roman %s" % mathdesign_dict[val]
|
|
|
|
|
|
def revert_newtxmath(document):
|
|
" 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:
|
|
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():
|
|
add_to_preamble(document, mathfont_dict[val])
|
|
document.header[i] = "\\font_math auto"
|
|
|
|
|
|
def revert_biolinum(document):
|
|
" Revert native biolinum font definition to LaTeX "
|
|
|
|
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
|
|
j = find_token(document.header, "\\font_osf true", 0)
|
|
if j != -1:
|
|
osf = True
|
|
preamble = "\\usepackage"
|
|
if not osf:
|
|
preamble += "[lf]"
|
|
preamble += "{biolinum-type1}"
|
|
add_to_preamble(document, [preamble])
|
|
document.header[i] = "\\font_sans default"
|
|
|
|
|
|
def revert_uop(document):
|
|
" Revert native URW Classico (Optima) font definition to LaTeX "
|
|
|
|
if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
|
|
i = find_token(document.header, "\\font_sans uop", 0)
|
|
if i != -1:
|
|
preamble = "\\renewcommand{\\sfdefault}{uop}"
|
|
add_to_preamble(document, [preamble])
|
|
document.header[i] = "\\font_sans default"
|
|
|
|
|
|
def convert_latexargs(document):
|
|
" Convert InsetArgument to new syntax "
|
|
|
|
if find_token(document.body, "\\begin_inset Argument", 0) == -1:
|
|
# nothing to do.
|
|
return
|
|
|
|
# A list of layouts (document classes) with only optional or no arguments.
|
|
# These can be safely converted to the new syntax
|
|
# (I took the liberty to add some of my personal layouts/modules here; JSP)
|
|
safe_layouts = ["aa", "aapaper", "aastex", "achemso", "acmsiggraph", "AEA",
|
|
"agu-dtd", "agums", "agutex", "amsart", "amsbook", "apa",
|
|
"arab-article", "armenian-article", "article-beamer", "article",
|
|
"beamer", "book", "broadway", "chess", "cl2emult", "ctex-article",
|
|
"ctex-book", "ctex-report", "dinbrief", "docbook-book", "docbook-chapter",
|
|
"docbook", "docbook-section", "doublecol-new", "dtk", "ectaart", "egs",
|
|
"elsarticle", "elsart", "entcs", "europecv", "extarticle", "extbook",
|
|
"extletter", "extreport", "foils", "frletter", "g-brief2", "g-brief",
|
|
"heb-article", "heb-letter", "hollywood", "IEEEtran", "ijmpc", "ijmpd",
|
|
"iopart", "isprs", "jarticle", "jasatex", "jbook", "jgrga", "jreport",
|
|
"jsarticle", "jsbeamer", "jsbook", "jss", "kluwer", "latex8", "letter", "lettre",
|
|
"literate-article", "literate-book", "literate-report", "llncs", "ltugboat",
|
|
"memoir", "moderncv", "mwart", "mwbk", "mwrep", "paper", "powerdot",
|
|
"recipebook", "report", "revtex4", "revtex", "scrartcl", "scrarticle-beamer",
|
|
"scrbook", "scrlettr", "scrlttr2", "scrreprt", "seminar", "siamltex",
|
|
"sigplanconf", "simplecv", "singlecol", "singlecol-new", "slides", "spie",
|
|
"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",
|
|
"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",
|
|
"theorems-chap-bytype", "theorems-chap", "theorems-named", "theorems-sec-bytype",
|
|
"theorems-sec", "theorems-starred", "theorems-std", "todonotes"]
|
|
# Modules we need to take care of
|
|
caveat_modules = ["initials"]
|
|
# information about the relevant styles in caveat_modules (number of opt and req args)
|
|
# use this if we get more caveat_modules. For now, use hard coding (see below).
|
|
# initials = [{'Layout' : 'Initial', 'opt' : 1, 'req' : 1}]
|
|
|
|
# Is this a known safe layout?
|
|
safe_layout = document.textclass in safe_layouts
|
|
if not safe_layout:
|
|
document.warning("Lyx2lyx knows nothing about textclass '%s'. "
|
|
"Please check if short title insets have been converted correctly."
|
|
% document.textclass)
|
|
# Do we use unsafe or unknown modules
|
|
mods = document.get_module_list()
|
|
unknown_modules = False
|
|
used_caveat_modules = list()
|
|
for mod in mods:
|
|
if mod in safe_modules:
|
|
continue
|
|
if mod in caveat_modules:
|
|
used_caveat_modules.append(mod)
|
|
continue
|
|
unknown_modules = True
|
|
document.warning("Lyx2lyx knows nothing about module '%s'. "
|
|
"Please check if short title insets have been converted correctly."
|
|
% mod)
|
|
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, "\\begin_inset Argument", i)
|
|
if i == -1:
|
|
return
|
|
|
|
if not safe_layout or unknown_modules:
|
|
# We cannot do more here since we have no access to this layout.
|
|
# InsetArgument itself will do the real work
|
|
# (see InsetArgument::updateBuffer())
|
|
document.body[i] = "\\begin_inset Argument 999"
|
|
i = i + 1
|
|
continue
|
|
|
|
# Find containing paragraph layout
|
|
parent = get_containing_layout(document.body, i)
|
|
if parent == False:
|
|
document.warning("Malformed lyx document: Can't find parent paragraph layout")
|
|
i = i + 1
|
|
continue
|
|
parbeg = parent[1]
|
|
parend = parent[2]
|
|
allowed_opts = -1
|
|
first_req = -1
|
|
if len(used_caveat_modules) > 0:
|
|
# We know for now that this must be the initials module with the Initial layout
|
|
# If we get more such modules, we need some automating.
|
|
if parent[0] == "Initial":
|
|
# Layout has 1 opt and 1 req arg.
|
|
# Count the actual arguments
|
|
actualargs = 0
|
|
for p in range(parbeg, parend):
|
|
if document.body[p] == "\\begin_inset Argument":
|
|
actualargs += 1
|
|
if actualargs == 1:
|
|
allowed_opts = 0
|
|
first_req = 2
|
|
# Collect all arguments in this paragraph
|
|
argnr = 0
|
|
for p in range(parbeg, parend):
|
|
if document.body[p] == "\\begin_inset Argument":
|
|
argnr += 1
|
|
if allowed_opts != -1:
|
|
# We have less arguments than opt + required.
|
|
# required must take precedence.
|
|
if argnr > allowed_opts and argnr < first_req:
|
|
argnr = first_req
|
|
document.body[p] = "\\begin_inset Argument %d" % argnr
|
|
i = i + 1
|
|
|
|
|
|
def revert_latexargs(document):
|
|
" Revert InsetArgument to old syntax "
|
|
|
|
i = 0
|
|
rx = re.compile(r'^\\begin_inset Argument (\d+)$')
|
|
args = dict()
|
|
while True:
|
|
# Search for Argument insets
|
|
i = find_token(document.body, "\\begin_inset Argument", i)
|
|
if i == -1:
|
|
return
|
|
m = rx.match(document.body[i])
|
|
if not m:
|
|
# No ID: inset already reverted
|
|
i = i + 1
|
|
continue
|
|
# Find containing paragraph layout
|
|
parent = get_containing_layout(document.body, i)
|
|
if parent == False:
|
|
document.warning("Malformed lyx document: Can't find parent paragraph layout")
|
|
i = i + 1
|
|
continue
|
|
parbeg = parent[1]
|
|
parend = parent[2]
|
|
realparbeg = parent[3]
|
|
# Collect all arguments in this paragraph
|
|
realparend = parend
|
|
for p in range(parbeg, parend):
|
|
m = rx.match(document.body[p])
|
|
if m:
|
|
val = int(m.group(1))
|
|
j = find_end_of_inset(document.body, p)
|
|
# Revert to old syntax
|
|
document.body[p] = "\\begin_inset Argument"
|
|
if j == -1:
|
|
document.warning("Malformed lyx document: Can't find end of Argument inset")
|
|
continue
|
|
if val > 0:
|
|
args[val] = document.body[p : j + 1]
|
|
# Adjust range end
|
|
realparend = realparend - len(document.body[p : j + 1])
|
|
# Remove arg inset at this position
|
|
del document.body[p : j + 1]
|
|
if p >= realparend:
|
|
break
|
|
# Now sort the arg insets
|
|
subst = [""]
|
|
for f in sorted(args):
|
|
subst += args[f]
|
|
del args[f]
|
|
# Insert the sorted arg insets at paragraph begin
|
|
document.body[realparbeg : realparbeg] = subst
|
|
|
|
i = realparbeg + 1 + len(subst)
|
|
|
|
|
|
def revert_Argument_to_TeX_brace(document, line, n, nmax, environment):
|
|
'''
|
|
Reverts an InsetArgument to TeX-code
|
|
usage:
|
|
revert_Argument_to_TeX_brace(document, LineOfBeginLayout, StartArgument, EndArgument, isEnvironment)
|
|
LineOfBeginLayout is the line of the \begin_layout statement
|
|
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
|
|
isEnvironment must be true, if the layout id for a LaTeX environment
|
|
'''
|
|
lineArg = 0
|
|
while lineArg != -1 and n < nmax + 1:
|
|
lineArg = find_token(document.body, "\\begin_inset Argument " + str(n), line)
|
|
if lineArg != -1:
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", lineArg)
|
|
# we have to assure that no other inset is in the Argument
|
|
beginInset = find_token(document.body, "\\begin_inset", beginPlain)
|
|
endInset = find_token(document.body, "\\end_inset", beginPlain)
|
|
k = beginPlain + 1
|
|
l = k
|
|
while beginInset < endInset and beginInset != -1:
|
|
beginInset = find_token(document.body, "\\begin_inset", k)
|
|
endInset = find_token(document.body, "\\end_inset", l)
|
|
k = beginInset + 1
|
|
l = endInset + 1
|
|
if environment == False:
|
|
document.body[endInset - 2 : endInset + 1] = put_cmd_in_ert("}{")
|
|
del(document.body[lineArg : beginPlain + 1])
|
|
else:
|
|
document.body[endInset - 2 : endInset + 1] = put_cmd_in_ert("}")
|
|
document.body[lineArg : beginPlain + 1] = put_cmd_in_ert("{")
|
|
n = n + 1
|
|
|
|
|
|
def revert_IEEEtran(document):
|
|
'''
|
|
Reverts InsetArgument of
|
|
Page headings
|
|
Biography
|
|
Biography without photo
|
|
to TeX-code
|
|
'''
|
|
if document.textclass == "IEEEtran":
|
|
i = 0
|
|
j = 0
|
|
k = 0
|
|
while True:
|
|
if i != -1:
|
|
i = find_token(document.body, "\\begin_layout Page headings", i)
|
|
if i != -1:
|
|
revert_Argument_to_TeX_brace(document, i, 1, 1, False)
|
|
i = i + 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, 1, 1, True)
|
|
j = 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 = k + 1
|
|
continue
|
|
if k != -1:
|
|
# start with the second argument, therefore 2
|
|
revert_Argument_to_TeX_brace(document, k, 2, 2, True)
|
|
k = k + 1
|
|
if i == -1 and j == -1 and k == -1:
|
|
return
|
|
|
|
|
|
def convert_TeX_brace_to_Argument(document, line, n, nmax, inset, environment):
|
|
'''
|
|
Converts TeX code for mandatory arguments to an InsetArgument
|
|
The conversion of TeX code for optional arguments must be done with another routine
|
|
!!! Be careful if the braces are different in your case as expected here:
|
|
- "}{" separates mandatory arguments of commands
|
|
- "}" + "{" separates mandatory arguments of commands
|
|
- "}" + " " + "{" separates mandatory arguments of commands
|
|
- { and } surround a mandatory argument of an environment
|
|
usage:
|
|
convert_TeX_brace_to_Argument(document, LineOfBeginLayout/Inset, StartArgument, EndArgument, isInset, isEnvironment)
|
|
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
|
|
|
|
Todo: this routine can currently handle only one mandatory argument of environments
|
|
'''
|
|
lineERT = line
|
|
endn = line
|
|
loop = 1
|
|
while lineERT != -1 and n < nmax + 1:
|
|
lineERT = find_token(document.body, "\\begin_inset ERT", lineERT)
|
|
if environment == False and lineERT != -1:
|
|
bracePair = find_token(document.body, "}{", lineERT)
|
|
# assure that the "}{" is in this ERT
|
|
if bracePair == lineERT + 5:
|
|
end = find_token(document.body, "\\end_inset", bracePair)
|
|
document.body[lineERT : end + 1] = ["\\end_layout", "", "\\end_inset"]
|
|
if loop == 1:
|
|
# in the case that n > 1 we have optional arguments before
|
|
# therefore detect them if any
|
|
if n > 1:
|
|
# first check if there is an argument
|
|
lineArg = find_token(document.body, "\\begin_inset Argument", line)
|
|
if lineArg < lineERT and lineArg != -1:
|
|
# we have an argument, so now search backwards for its end
|
|
# we must now assure that we don't find other insets like e.g. a newline
|
|
endInsetArg = lineERT
|
|
endLayoutArg = endInsetArg
|
|
while endInsetArg != endLayoutArg + 2 and endInsetArg != -1:
|
|
endInsetArg = endInsetArg - 1
|
|
endLayoutArg = endInsetArg
|
|
endInsetArg = find_token_backwards(document.body, "\\end_inset", endInsetArg)
|
|
endLayoutArg = find_token_backwards(document.body, "\\end_layout", endLayoutArg)
|
|
line = endInsetArg + 1
|
|
if inset == False:
|
|
document.body[line + 1 : line + 1] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
|
|
else:
|
|
document.body[line + 4 : line + 4] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
|
|
else:
|
|
document.body[endn : endn] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
|
|
n = n + 1
|
|
endn = end
|
|
loop = loop + 1
|
|
# now check the case that we have "}" + "{" in two ERTs
|
|
else:
|
|
endBrace = find_token(document.body, "}", lineERT)
|
|
if endBrace == lineERT + 5:
|
|
beginBrace = find_token(document.body, "{", endBrace)
|
|
# 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:
|
|
end = find_token(document.body, "\\end_inset", beginBrace)
|
|
document.body[lineERT : end + 1] = ["\\end_layout", "", "\\end_inset"]
|
|
if loop == 1:
|
|
# in the case that n > 1 we have optional arguments before
|
|
# therefore detect them if any
|
|
if n > 1:
|
|
# first check if there is an argument
|
|
lineArg = find_token(document.body, "\\begin_inset Argument", line)
|
|
if lineArg < lineERT and lineArg != -1:
|
|
# we have an argument, so now search backwards for its end
|
|
# we must now assure that we don't find other insets like e.g. a newline
|
|
endInsetArg = lineERT
|
|
endLayoutArg = endInsetArg
|
|
while endInsetArg != endLayoutArg + 2 and endInsetArg != -1:
|
|
endInsetArg = endInsetArg - 1
|
|
endLayoutArg = endInsetArg
|
|
endInsetArg = find_token_backwards(document.body, "\\end_inset", endInsetArg)
|
|
endLayoutArg = find_token_backwards(document.body, "\\end_layout", endLayoutArg)
|
|
line = endInsetArg + 1
|
|
if inset == False:
|
|
document.body[line + 1 : line + 1] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
|
|
else:
|
|
document.body[line + 4 : line + 4] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
|
|
else:
|
|
document.body[endn : endn] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
|
|
n = n + 1
|
|
loop = loop + 1
|
|
# set the line where the next argument will be inserted
|
|
if beginBrace == endBrace + 11:
|
|
endn = end - 11
|
|
else:
|
|
endn = end - 12
|
|
else:
|
|
lineERT = lineERT + 1
|
|
if environment == True and lineERT != -1:
|
|
opening = find_token(document.body, "{", lineERT)
|
|
if opening == lineERT + 5: # assure that the "{" is in this ERT
|
|
end = find_token(document.body, "\\end_inset", opening)
|
|
document.body[lineERT : end + 1] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
|
|
n = n + 1
|
|
lineERT2 = find_token(document.body, "\\begin_inset ERT", lineERT)
|
|
closing = find_token(document.body, "}", lineERT2)
|
|
if closing == lineERT2 + 5: # assure that the "}" is in this ERT
|
|
end2 = find_token(document.body, "\\end_inset", closing)
|
|
document.body[lineERT2 : end2 + 1] = ["\\end_layout", "", "\\end_inset"]
|
|
else:
|
|
lineERT = lineERT + 1
|
|
|
|
|
|
def convert_IEEEtran(document):
|
|
'''
|
|
Converts ERT of
|
|
Page headings
|
|
Biography
|
|
Biography without photo
|
|
to InsetArgument
|
|
'''
|
|
if document.textclass == "IEEEtran":
|
|
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)
|
|
i = 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)
|
|
j = 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 = k + 1
|
|
continue
|
|
if k != -1:
|
|
# the argument we want to convert is the second one
|
|
convert_TeX_brace_to_Argument(document, k, 2, 2, False, True)
|
|
k = k + 1
|
|
if i == -1 and j == -1 and k == -1:
|
|
return
|
|
|
|
|
|
def revert_AASTeX(document):
|
|
" Reverts InsetArgument of Altaffilation to TeX-code "
|
|
if document.textclass == "aastex":
|
|
i = 0
|
|
while True:
|
|
if i != -1:
|
|
i = find_token(document.body, "\\begin_layout Altaffilation", i)
|
|
if i != -1:
|
|
revert_Argument_to_TeX_brace(document, i, 1, 1, False)
|
|
i = i + 1
|
|
if i == -1:
|
|
return
|
|
|
|
|
|
def convert_AASTeX(document):
|
|
" Converts ERT of Altaffilation to InsetArgument "
|
|
if document.textclass == "aastex":
|
|
i = 0
|
|
while True:
|
|
if i != -1:
|
|
i = find_token(document.body, "\\begin_layout Altaffilation", i)
|
|
if i != -1:
|
|
convert_TeX_brace_to_Argument(document, i, 1, 1, False, False)
|
|
i = i + 1
|
|
if i == -1:
|
|
return
|
|
|
|
|
|
def revert_AGUTeX(document):
|
|
" Reverts InsetArgument of Author affiliation to TeX-code "
|
|
if document.textclass == "agutex":
|
|
i = 0
|
|
while True:
|
|
if i != -1:
|
|
i = find_token(document.body, "\\begin_layout Author affiliation", i)
|
|
if i != -1:
|
|
revert_Argument_to_TeX_brace(document, i, 1, 1, False)
|
|
i = i + 1
|
|
if i == -1:
|
|
return
|
|
|
|
|
|
def convert_AGUTeX(document):
|
|
" Converts ERT of Author affiliation to InsetArgument "
|
|
if document.textclass == "agutex":
|
|
i = 0
|
|
while True:
|
|
if i != -1:
|
|
i = find_token(document.body, "\\begin_layout Author affiliation", i)
|
|
if i != -1:
|
|
convert_TeX_brace_to_Argument(document, i, 1, 1, False, False)
|
|
i = i + 1
|
|
if i == -1:
|
|
return
|
|
|
|
|
|
def revert_IJMP(document):
|
|
" Reverts InsetArgument of MarkBoth to TeX-code "
|
|
if document.textclass == "ijmpc" or document.textclass == "ijmpd":
|
|
i = 0
|
|
while True:
|
|
if i != -1:
|
|
i = find_token(document.body, "\\begin_layout MarkBoth", i)
|
|
if i != -1:
|
|
revert_Argument_to_TeX_brace(document, i, 1, 1, False)
|
|
i = i + 1
|
|
if i == -1:
|
|
return
|
|
|
|
|
|
def convert_IJMP(document):
|
|
" Converts ERT of MarkBoth to InsetArgument "
|
|
if document.textclass == "ijmpc" or document.textclass == "ijmpd":
|
|
i = 0
|
|
while True:
|
|
if i != -1:
|
|
i = find_token(document.body, "\\begin_layout MarkBoth", i)
|
|
if i != -1:
|
|
convert_TeX_brace_to_Argument(document, i, 1, 1, False, False)
|
|
i = i + 1
|
|
if i == -1:
|
|
return
|
|
|
|
|
|
def revert_SIGPLAN(document):
|
|
" Reverts InsetArgument of MarkBoth to TeX-code "
|
|
if document.textclass == "sigplanconf":
|
|
i = 0
|
|
j = 0
|
|
while True:
|
|
if i != -1:
|
|
i = find_token(document.body, "\\begin_layout Conference", i)
|
|
if i != -1:
|
|
revert_Argument_to_TeX_brace(document, i, 1, 1, False)
|
|
i = i + 1
|
|
if j != -1:
|
|
j = find_token(document.body, "\\begin_layout Author", j)
|
|
if j != -1:
|
|
revert_Argument_to_TeX_brace(document, j, 1, 2, False)
|
|
j = j + 1
|
|
if i == -1 and j == -1:
|
|
return
|
|
|
|
|
|
def convert_SIGPLAN(document):
|
|
" Converts ERT of MarkBoth to InsetArgument "
|
|
if document.textclass == "sigplanconf":
|
|
i = 0
|
|
j = 0
|
|
while True:
|
|
if i != -1:
|
|
i = find_token(document.body, "\\begin_layout Conference", i)
|
|
if i != -1:
|
|
convert_TeX_brace_to_Argument(document, i, 1, 1, False, False)
|
|
i = i + 1
|
|
if j != -1:
|
|
j = find_token(document.body, "\\begin_layout Author", j)
|
|
if j != -1:
|
|
convert_TeX_brace_to_Argument(document, j, 1, 2, False, False)
|
|
j = j + 1
|
|
if i == -1 and j == -1:
|
|
return
|
|
|
|
|
|
def revert_SIGGRAPH(document):
|
|
" Reverts InsetArgument of Flex CRcat to TeX-code "
|
|
if document.textclass == "acmsiggraph":
|
|
i = 0
|
|
while True:
|
|
if i != -1:
|
|
i = find_token(document.body, "\\begin_inset Flex CRcat", i)
|
|
if i != -1:
|
|
revert_Argument_to_TeX_brace(document, i, 1, 3, False)
|
|
i = i + 1
|
|
if i == -1:
|
|
return
|
|
|
|
|
|
def convert_SIGGRAPH(document):
|
|
" Converts ERT of Flex CRcat to InsetArgument "
|
|
if document.textclass == "acmsiggraph":
|
|
i = 0
|
|
while True:
|
|
if i != -1:
|
|
i = find_token(document.body, "\\begin_inset Flex CRcat", i)
|
|
if i != -1:
|
|
convert_TeX_brace_to_Argument(document, i, 1, 3, True, False)
|
|
i = i + 1
|
|
if i == -1:
|
|
return
|
|
|
|
|
|
def revert_EuropeCV(document):
|
|
" Reverts InsetArgument of Flex CRcat to TeX-code "
|
|
if document.textclass == "europecv":
|
|
i = 0
|
|
j = 0
|
|
k = 0
|
|
m = 0
|
|
while True:
|
|
if i != -1:
|
|
i = find_token(document.body, "\\begin_layout Item", i)
|
|
if i != -1:
|
|
revert_Argument_to_TeX_brace(document, i, 2, 2, False)
|
|
i = i + 1
|
|
if j != -1:
|
|
j = find_token(document.body, "\\begin_layout BulletedItem", j)
|
|
if j != -1:
|
|
revert_Argument_to_TeX_brace(document, j, 2, 2, False)
|
|
j = j + 1
|
|
if k != -1:
|
|
k = find_token(document.body, "\\begin_layout Language", k)
|
|
if k != -1:
|
|
revert_Argument_to_TeX_brace(document, k, 2, 6, False)
|
|
k = k + 1
|
|
if m != -1:
|
|
m = find_token(document.body, "\\begin_layout LastLanguage", m)
|
|
if m != -1:
|
|
revert_Argument_to_TeX_brace(document, m, 2, 6, False)
|
|
m = m + 1
|
|
if i == -1 and j == -1 and k == -1 and m == -1:
|
|
return
|
|
|
|
|
|
def convert_EuropeCV(document):
|
|
" Converts ERT of Flex CRcat to InsetArgument "
|
|
if document.textclass == "europecv":
|
|
i = 0
|
|
j = 0
|
|
k = 0
|
|
m = 0
|
|
while True:
|
|
if i != -1:
|
|
i = find_token(document.body, "\\begin_layout Item", i)
|
|
if i != -1:
|
|
convert_TeX_brace_to_Argument(document, i, 2, 2, False, False)
|
|
i = i + 1
|
|
if j != -1:
|
|
j = find_token(document.body, "\\begin_layout BulletedItem", j)
|
|
if j != -1:
|
|
convert_TeX_brace_to_Argument(document, j, 2, 2, False, False)
|
|
j = j + 1
|
|
if k != -1:
|
|
k = find_token(document.body, "\\begin_layout Language", k)
|
|
if k != -1:
|
|
convert_TeX_brace_to_Argument(document, k, 2, 6, False, False)
|
|
k = k + 1
|
|
if m != -1:
|
|
m = find_token(document.body, "\\begin_layout LastLanguage", m)
|
|
if m != -1:
|
|
convert_TeX_brace_to_Argument(document, m, 2, 6, False, False)
|
|
m = m + 1
|
|
if i == -1 and j == -1 and k == -1 and m == -1:
|
|
return
|
|
|
|
|
|
def revert_literate(document):
|
|
" Revert Literate document to old format "
|
|
if del_token(document.header, "noweb", 0):
|
|
document.textclass = "literate-" + document.textclass
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, "\\begin_layout Chunk", i)
|
|
if i == -1:
|
|
break
|
|
document.body[i] = "\\begin_layout Scrap"
|
|
i = i + 1
|
|
|
|
|
|
def convert_literate(document):
|
|
" Convert Literate document to new format"
|
|
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)
|
|
if (j != -1):
|
|
document.header.insert(j + 1, "noweb")
|
|
else:
|
|
document.header.insert(i + 1, "\\end_modules")
|
|
document.header.insert(i + 1, "noweb")
|
|
document.header.insert(i + 1, "\\begin_modules")
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, "\\begin_layout Scrap", i)
|
|
if i == -1:
|
|
break
|
|
document.body[i] = "\\begin_layout Chunk"
|
|
i = i + 1
|
|
|
|
|
|
def revert_itemargs(document):
|
|
" Reverts \\item arguments to TeX-code "
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, "\\begin_inset Argument item:", i)
|
|
if i == -1:
|
|
return
|
|
j = find_end_of_inset(document.body, i)
|
|
# Find containing paragraph layout
|
|
parent = get_containing_layout(document.body, i)
|
|
if parent == False:
|
|
document.warning("Malformed lyx document: Can't find parent paragraph layout")
|
|
i = i + 1
|
|
continue
|
|
parbeg = parent[3]
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", i)
|
|
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[parbeg : parbeg] = subst
|
|
i = i + 1
|
|
|
|
|
|
def revert_garamondx_newtxmath(document):
|
|
" 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:
|
|
val = get_value(document.header, "\\font_math", i)
|
|
if val == "garamondx-ntxm":
|
|
add_to_preamble(document, "\\usepackage[garamondx]{newtxmath}")
|
|
document.header[i] = "\\font_math auto"
|
|
|
|
|
|
def revert_garamondx(document):
|
|
" Revert native garamond font definition to LaTeX "
|
|
|
|
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
|
|
j = find_token(document.header, "\\font_osf true", 0)
|
|
if j != -1:
|
|
osf = True
|
|
preamble = "\\usepackage"
|
|
if osf:
|
|
preamble += "[osfI]"
|
|
preamble += "{garamondx}"
|
|
add_to_preamble(document, [preamble])
|
|
document.header[i] = "\\font_roman default"
|
|
|
|
|
|
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
|
|
|
|
shifted_layouts = ["Part", "Section", "Subsection", "Subsubsection"]
|
|
list_layouts = ["Itemize", "Enumerate", "Description"]
|
|
rx = re.compile(r'^\\begin_inset Argument (\d+)$')
|
|
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, "\\begin_inset Argument", i)
|
|
if i == -1:
|
|
return
|
|
# Find containing paragraph layout
|
|
parent = get_containing_layout(document.body, i)
|
|
if parent == False:
|
|
document.warning("Malformed lyx document: Can't find parent paragraph layout")
|
|
i = i + 1
|
|
continue
|
|
parbeg = parent[1]
|
|
parend = parent[2]
|
|
layoutname = parent[0]
|
|
for p in range(parbeg, parend):
|
|
if layoutname in shifted_layouts:
|
|
m = rx.match(document.body[p])
|
|
if m:
|
|
argnr = int(m.group(1))
|
|
argnr += 1
|
|
document.body[p] = "\\begin_inset Argument %d" % argnr
|
|
if layoutname == "AgainFrame":
|
|
m = rx.match(document.body[p])
|
|
if m:
|
|
document.body[p] = "\\begin_inset Argument 3"
|
|
if document.body[p + 4] == "\\begin_inset ERT":
|
|
if document.body[p + 9].startswith("<"):
|
|
# This is an overlay specification
|
|
# strip off the <
|
|
document.body[p + 9] = document.body[p + 9][1:]
|
|
if document.body[p + 9].endswith(">"):
|
|
# strip off the >
|
|
document.body[p + 9] = document.body[p + 9][:-1]
|
|
# Shift this one
|
|
document.body[p] = "\\begin_inset Argument 2"
|
|
if layoutname in list_layouts:
|
|
m = rx.match(document.body[p])
|
|
if m:
|
|
if m.group(1) == "1":
|
|
if document.body[p + 4] == "\\begin_inset ERT":
|
|
if document.body[p + 9].startswith("<"):
|
|
# This is an overlay specification
|
|
# strip off the <
|
|
document.body[p + 9] = document.body[p + 9][1:]
|
|
if document.body[p + 9].endswith(">"):
|
|
# strip off the >
|
|
document.body[p + 9] = document.body[p + 9][:-1]
|
|
elif layoutname != "Itemize":
|
|
# Shift this one
|
|
document.body[p] = "\\begin_inset Argument 2"
|
|
i = i + 1
|
|
|
|
|
|
def convert_againframe_args(document):
|
|
" Converts beamer AgainFrame to new layout "
|
|
|
|
# FIXME: This currently only works if the arguments are in one single ERT
|
|
|
|
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)
|
|
if i == -1:
|
|
break
|
|
parent = get_containing_layout(document.body, i)
|
|
if parent[1] != i:
|
|
document.warning("Wrong parent layout!")
|
|
j = parent[2]
|
|
parbeg = parent[3]
|
|
if i != -1:
|
|
if document.body[parbeg] == "\\begin_inset ERT":
|
|
ertcont = parbeg + 5
|
|
if document.body[ertcont].startswith("[<"):
|
|
# This is a default overlay specification
|
|
# strip off the [<
|
|
document.body[ertcont] = document.body[ertcont][2:]
|
|
if document.body[ertcont].endswith(">]"):
|
|
# strip off the >]
|
|
document.body[ertcont] = document.body[ertcont][:-2]
|
|
elif document.body[ertcont].endswith("]"):
|
|
# divide the args
|
|
tok = document.body[ertcont].find('>][')
|
|
if tok != -1:
|
|
subst = [document.body[ertcont][:tok],
|
|
'\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 3',
|
|
'status collapsed', '', '\\begin_layout Plain Layout',
|
|
document.body[ertcont][tok + 3:-1]]
|
|
document.body[ertcont : ertcont + 1] = subst
|
|
# Convert to ArgInset
|
|
document.body[parbeg] = "\\begin_inset Argument 2"
|
|
i = j
|
|
continue
|
|
elif document.body[ertcont].startswith("<"):
|
|
# This is an overlay specification
|
|
# strip off the <
|
|
document.body[ertcont] = document.body[ertcont][1:]
|
|
if document.body[ertcont].endswith(">"):
|
|
# strip off the >
|
|
document.body[ertcont] = document.body[ertcont][:-1]
|
|
# Convert to ArgInset
|
|
document.body[parbeg] = "\\begin_inset Argument 1"
|
|
elif document.body[ertcont].endswith(">]"):
|
|
# divide the args
|
|
tok = document.body[ertcont].find('>[<')
|
|
if tok != -1:
|
|
document.body[ertcont : ertcont + 1] = [document.body[ertcont][:tok],
|
|
'\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 2',
|
|
'status collapsed', '', '\\begin_layout Plain Layout',
|
|
document.body[ertcont][tok + 3:-2]]
|
|
# Convert to ArgInset
|
|
document.body[parbeg] = "\\begin_inset Argument 1"
|
|
elif document.body[ertcont].endswith("]"):
|
|
# divide the args
|
|
tok = document.body[ertcont].find('>[<')
|
|
if tok != -1:
|
|
# divide the args
|
|
tokk = document.body[ertcont].find('>][')
|
|
if tokk != -1:
|
|
document.body[ertcont : ertcont + 1] = [document.body[ertcont][:tok],
|
|
'\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 2',
|
|
'status collapsed', '', '\\begin_layout Plain Layout',
|
|
document.body[ertcont][tok + 3:tokk],
|
|
'\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 3',
|
|
'status collapsed', '', '\\begin_layout Plain Layout',
|
|
document.body[ertcont][tokk + 3:-1]]
|
|
else:
|
|
tokk = document.body[ertcont].find('>[')
|
|
if tokk != -1:
|
|
document.body[ertcont : ertcont + 1] = [document.body[ertcont][:tokk],
|
|
'\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 3',
|
|
'status collapsed', '', '\\begin_layout Plain Layout',
|
|
document.body[ertcont][tokk + 2:-1]]
|
|
# Convert to ArgInset
|
|
document.body[parbeg] = "\\begin_inset Argument 1"
|
|
i = j
|
|
continue
|
|
elif document.body[ertcont].startswith("["):
|
|
# This is an ERT option
|
|
# strip off the [
|
|
document.body[ertcont] = document.body[ertcont][1:]
|
|
if document.body[ertcont].endswith("]"):
|
|
# strip off the ]
|
|
document.body[ertcont] = document.body[ertcont][:-1]
|
|
# Convert to ArgInset
|
|
document.body[parbeg] = "\\begin_inset Argument 3"
|
|
i = j
|
|
continue
|
|
i = j
|
|
|
|
|
|
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
|
|
while True:
|
|
i = find_token_exact(document.body, "\\begin_layout " + lay, i)
|
|
if i == -1:
|
|
break
|
|
parent = get_containing_layout(document.body, i)
|
|
if parent[1] != i:
|
|
document.warning("Wrong parent layout!")
|
|
j = parent[2]
|
|
parbeg = parent[3]
|
|
if i != -1:
|
|
if document.body[parbeg] == "\\begin_inset ERT":
|
|
ertcont = parbeg + 5
|
|
if document.body[ertcont].startswith("<"):
|
|
# This is an overlay specification
|
|
# strip off the <
|
|
document.body[ertcont] = document.body[ertcont][1:]
|
|
if document.body[ertcont].endswith(">"):
|
|
# strip off the >
|
|
document.body[ertcont] = document.body[ertcont][:-1]
|
|
elif document.body[ertcont].endswith("]"):
|
|
# divide the args
|
|
tok = document.body[ertcont].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"
|
|
i = j
|
|
continue
|
|
elif document.body[ertcont].startswith("["):
|
|
# This is an ERT option
|
|
# strip off the [
|
|
document.body[ertcont] = document.body[ertcont][1:]
|
|
if document.body[ertcont].endswith("]"):
|
|
# strip off the ]
|
|
document.body[ertcont] = document.body[ertcont][:-1]
|
|
# Convert to ArgInset
|
|
document.body[parbeg] = "\\begin_inset Argument 2"
|
|
i = j
|
|
continue
|
|
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
|
|
while True:
|
|
i = find_token(document.body, "\\begin_layout " + lay, i)
|
|
if i == -1:
|
|
break
|
|
parent = get_containing_layout(document.body, i)
|
|
if parent[1] != i:
|
|
document.warning("Wrong parent layout!")
|
|
j = parent[2]
|
|
parbeg = parent[3]
|
|
if i != -1:
|
|
if document.body[parbeg] == "\\begin_inset ERT":
|
|
if document.body[i + 6].startswith("<"):
|
|
# This is an overlay specification
|
|
# strip off the <
|
|
document.body[i + 6] = document.body[i + 6][1:]
|
|
if document.body[i + 6].endswith(">"):
|
|
# strip off the >
|
|
document.body[i + 6] = document.body[i + 6][:-1]
|
|
# Convert to ArgInset
|
|
document.body[i + 1] = "\\begin_inset Argument 1"
|
|
i = j
|
|
|
|
|
|
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
|
|
|
|
i = 0
|
|
list_layouts = ["Itemize", "Enumerate", "Description"]
|
|
headings = ["Part", "Section", "Section*", "Subsection", "Subsection*",
|
|
"Subsubsection", "Subsubsection*", "FrameSubtitle", "NoteItem"]
|
|
quote_layouts = ["Uncover", "Only", "Quotation", "Quote", "Verse"]
|
|
corollary_layouts = ["Corollary", "Definition", "Definitions", "Example", "Examples", "Fact", "Proof", "Theorem"]
|
|
rx = re.compile(r'^\\begin_inset Argument (\S+)$')
|
|
|
|
while True:
|
|
i = find_token(document.body, "\\begin_inset Argument", i)
|
|
if i == -1:
|
|
return
|
|
# Find containing paragraph layout
|
|
parent = get_containing_layout(document.body, i)
|
|
if parent == False:
|
|
document.warning("Malformed lyx document: Can't find parent paragraph layout")
|
|
i = i + 1
|
|
continue
|
|
parbeg = parent[1]
|
|
parend = parent[2]
|
|
realparbeg = parent[3]
|
|
layoutname = parent[0]
|
|
realparend = parend
|
|
for p in range(parbeg, parend):
|
|
if p >= realparend:
|
|
i = realparend
|
|
break
|
|
if layoutname in headings:
|
|
m = rx.match(document.body[p])
|
|
if m:
|
|
argnr = m.group(1)
|
|
if argnr == "1":
|
|
# Find containing paragraph layout
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", p)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
endInset = find_end_of_inset(document.body, p)
|
|
argcontent = document.body[beginPlain + 1 : endPlain]
|
|
# Adjust range end
|
|
realparend = realparend - len(document.body[p : endInset + 1])
|
|
# Remove arg inset
|
|
del document.body[p : endInset + 1]
|
|
if layoutname == "FrameSubtitle":
|
|
pre = put_cmd_in_ert("\\" + layoutname.lower() + "<") + argcontent + put_cmd_in_ert(">")
|
|
elif layoutname == "NoteItem":
|
|
pre = put_cmd_in_ert("\\note<") + argcontent + put_cmd_in_ert(">[item]")
|
|
elif layoutname.endswith('*'):
|
|
pre = put_cmd_in_ert("\\lyxframeend\\" + layoutname.lower()[:-1] + "<") + argcontent + put_cmd_in_ert(">*")
|
|
else:
|
|
pre = put_cmd_in_ert("\\lyxframeend\\" + layoutname.lower() + "<") + argcontent + put_cmd_in_ert(">")
|
|
secarg = find_token(document.body, "\\begin_inset Argument 2", parbeg, parend)
|
|
if secarg != -1:
|
|
# Find containing paragraph layout
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", secarg)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
endInset = find_end_of_inset(document.body, secarg)
|
|
argcontent = document.body[beginPlain + 1 : endPlain]
|
|
# Adjust range end
|
|
realparend = realparend - len(document.body[secarg : endInset + 1])
|
|
del document.body[secarg : endInset + 1]
|
|
pre += put_cmd_in_ert("[") + argcontent + put_cmd_in_ert("]")
|
|
pre += put_cmd_in_ert("{")
|
|
document.body[parbeg] = "\\begin_layout Standard"
|
|
document.body[realparbeg : realparbeg] = pre
|
|
pe = find_end_of_layout(document.body, parbeg)
|
|
post = put_cmd_in_ert("}")
|
|
document.body[pe : pe] = post
|
|
realparend += len(pre) + len(post)
|
|
if layoutname == "AgainFrame":
|
|
m = rx.match(document.body[p])
|
|
if m:
|
|
argnr = m.group(1)
|
|
if argnr == "3":
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", p)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
endInset = find_end_of_inset(document.body, p)
|
|
content = document.body[beginPlain + 1 : endPlain]
|
|
# Adjust range end
|
|
realparend = realparend - len(document.body[p : endInset + 1])
|
|
# Remove arg inset
|
|
del document.body[p : endInset + 1]
|
|
subst = put_cmd_in_ert("[") + content + put_cmd_in_ert("]")
|
|
document.body[realparbeg : realparbeg] = subst
|
|
if layoutname == "Overprint":
|
|
m = rx.match(document.body[p])
|
|
if m:
|
|
argnr = m.group(1)
|
|
if argnr == "1":
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", p)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
endInset = find_end_of_inset(document.body, p)
|
|
content = document.body[beginPlain + 1 : endPlain]
|
|
# Adjust range end
|
|
realparend = realparend - len(document.body[p : endInset + 1])
|
|
# Remove arg inset
|
|
del document.body[p : endInset + 1]
|
|
subst = put_cmd_in_ert("[") + content + put_cmd_in_ert("]")
|
|
document.body[realparbeg : realparbeg] = subst
|
|
if layoutname == "OverlayArea":
|
|
m = rx.match(document.body[p])
|
|
if m:
|
|
argnr = m.group(1)
|
|
if argnr == "2":
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", p)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
endInset = find_end_of_inset(document.body, p)
|
|
content = document.body[beginPlain + 1 : endPlain]
|
|
# Adjust range end
|
|
realparend = realparend - len(document.body[p : endInset + 1])
|
|
# Remove arg inset
|
|
del document.body[p : endInset + 1]
|
|
subst = put_cmd_in_ert("{") + content + put_cmd_in_ert("}")
|
|
document.body[realparbeg : realparbeg] = subst
|
|
if layoutname in list_layouts:
|
|
m = rx.match(document.body[p])
|
|
if m:
|
|
argnr = m.group(1)
|
|
if argnr == "1":
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", p)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
endInset = find_end_of_inset(document.body, p)
|
|
content = document.body[beginPlain + 1 : endPlain]
|
|
# Adjust range end
|
|
realparend = realparend - len(document.body[p : endInset + 1])
|
|
# Remove arg inset
|
|
del document.body[p : endInset + 1]
|
|
subst = put_cmd_in_ert("<") + content + put_cmd_in_ert(">")
|
|
document.body[realparbeg : realparbeg] = subst
|
|
elif argnr == "item:1":
|
|
j = find_end_of_inset(document.body, i)
|
|
# Find containing paragraph layout
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", i)
|
|
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
|
|
elif argnr == "item:2":
|
|
j = find_end_of_inset(document.body, i)
|
|
# Find containing paragraph layout
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", i)
|
|
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 in quote_layouts:
|
|
m = rx.match(document.body[p])
|
|
if m:
|
|
argnr = m.group(1)
|
|
if argnr == "1":
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", p)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
endInset = find_end_of_inset(document.body, p)
|
|
content = document.body[beginPlain + 1 : endPlain]
|
|
# Adjust range end
|
|
realparend = realparend - len(document.body[p : endInset + 1])
|
|
# Remove arg inset
|
|
del document.body[p : endInset + 1]
|
|
subst = put_cmd_in_ert("<") + content + put_cmd_in_ert(">")
|
|
document.body[realparbeg : realparbeg] = subst
|
|
if layoutname in corollary_layouts:
|
|
m = rx.match(document.body[p])
|
|
if m:
|
|
argnr = m.group(1)
|
|
if argnr == "2":
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", p)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
endInset = find_end_of_inset(document.body, p)
|
|
content = document.body[beginPlain + 1 : endPlain]
|
|
# Adjust range end
|
|
realparend = realparend - len(document.body[p : endInset + 1])
|
|
# Remove arg inset
|
|
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
|
|
|
|
i = 0
|
|
shifted_layouts = ["Part", "Section", "Subsection", "Subsubsection"]
|
|
corollary_layouts = ["Corollary", "Definition", "Definitions", "Example", "Examples", "Fact", "Proof", "Theorem"]
|
|
rx = re.compile(r'^\\begin_inset Argument (\S+)$')
|
|
|
|
while True:
|
|
i = find_token(document.body, "\\begin_inset Argument", i)
|
|
if i == -1:
|
|
return
|
|
# Find containing paragraph layout
|
|
parent = get_containing_layout(document.body, i)
|
|
if parent == False:
|
|
document.warning("Malformed lyx document: Can't find parent paragraph layout")
|
|
i = i + 1
|
|
continue
|
|
parbeg = parent[1]
|
|
parend = parent[2]
|
|
realparbeg = parent[3]
|
|
layoutname = parent[0]
|
|
realparend = parend
|
|
for p in range(parbeg, parend):
|
|
if p >= realparend:
|
|
i = realparend
|
|
break
|
|
if layoutname in shifted_layouts:
|
|
m = rx.match(document.body[p])
|
|
if m:
|
|
argnr = m.group(1)
|
|
if argnr == "2":
|
|
document.body[p] = "\\begin_inset Argument 1"
|
|
if layoutname in corollary_layouts:
|
|
m = rx.match(document.body[p])
|
|
if m:
|
|
argnr = m.group(1)
|
|
if argnr == "1":
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", p)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
endInset = find_end_of_inset(document.body, p)
|
|
content = document.body[beginPlain + 1 : endPlain]
|
|
# Adjust range end
|
|
realparend = realparend - len(document.body[p : endInset + 1])
|
|
# Remove arg inset
|
|
del document.body[p : endInset + 1]
|
|
subst = put_cmd_in_ert("<") + content + put_cmd_in_ert(">")
|
|
document.body[realparbeg : realparbeg] = subst
|
|
if layoutname == "OverlayArea":
|
|
m = rx.match(document.body[p])
|
|
if m:
|
|
argnr = m.group(1)
|
|
if argnr == "1":
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", p)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
endInset = find_end_of_inset(document.body, p)
|
|
content = document.body[beginPlain + 1 : endPlain]
|
|
# Adjust range end
|
|
realparend = realparend - len(document.body[p : endInset + 1])
|
|
# Remove arg inset
|
|
del document.body[p : endInset + 1]
|
|
subst = put_cmd_in_ert("{") + content + put_cmd_in_ert("}")
|
|
document.body[realparbeg : realparbeg] = subst
|
|
if layoutname == "AgainFrame":
|
|
m = rx.match(document.body[p])
|
|
if m:
|
|
argnr = m.group(1)
|
|
if argnr == "2":
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", p)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
endInset = find_end_of_inset(document.body, p)
|
|
content = document.body[beginPlain + 1 : endPlain]
|
|
# Adjust range end
|
|
realparend = realparend - len(document.body[p : endInset + 1])
|
|
# Remove arg inset
|
|
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_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
|
|
|
|
rx = re.compile(r'^\\begin_inset Argument (\S+)$')
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, "\\begin_inset Argument", i)
|
|
if i == -1:
|
|
return
|
|
# Find containing paragraph layout
|
|
parent = get_containing_layout(document.body, i)
|
|
if parent == False:
|
|
document.warning("Malformed lyx document: Can't find parent paragraph layout")
|
|
i = i + 1
|
|
continue
|
|
parbeg = parent[1]
|
|
parend = parent[2]
|
|
realparbeg = parent[3]
|
|
layoutname = parent[0]
|
|
realparend = parend
|
|
for p in range(parbeg, parend):
|
|
if p >= realparend:
|
|
i = realparend
|
|
break
|
|
if layoutname == "AgainFrame":
|
|
m = rx.match(document.body[p])
|
|
if m:
|
|
argnr = m.group(1)
|
|
if argnr == "1":
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", p)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
endInset = find_end_of_inset(document.body, p)
|
|
content = document.body[beginPlain + 1 : endPlain]
|
|
# Adjust range end
|
|
realparend = realparend - len(document.body[p : endInset + 1])
|
|
# Remove arg inset
|
|
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_beamerflex(document):
|
|
" Reverts beamer Flex insets "
|
|
|
|
beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
|
|
if document.textclass not in beamer_classes:
|
|
return
|
|
|
|
new_flexes = {"Bold" : "\\textbf", "Emphasize" : "\\emph", "Only" : "\\only",
|
|
"Uncover" : "\\uncover", "Visible" : "\\visible",
|
|
"Invisible" : "\\invisible", "Alternative" : "\\alt",
|
|
"Beamer_Note" : "\\note"}
|
|
old_flexes = {"Alert" : "\\alert", "Structure" : "\\structure"}
|
|
rx = re.compile(r'^\\begin_inset Flex (.+)$')
|
|
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, "\\begin_inset Flex", i)
|
|
if i == -1:
|
|
return
|
|
m = rx.match(document.body[i])
|
|
if m:
|
|
flextype = m.group(1)
|
|
z = find_end_of_inset(document.body, i)
|
|
if z == -1:
|
|
document.warning("Can't find end of Flex " + flextype + " inset.")
|
|
i += 1
|
|
continue
|
|
if flextype in new_flexes:
|
|
pre = put_cmd_in_ert(new_flexes[flextype])
|
|
arg = find_token(document.body, "\\begin_inset Argument 1", i, z)
|
|
if arg != -1:
|
|
argend = find_end_of_inset(document.body, arg)
|
|
if argend == -1:
|
|
document.warning("Can't find end of Argument!")
|
|
i += 1
|
|
continue
|
|
# Find containing paragraph layout
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", arg)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
argcontent = document.body[beginPlain + 1 : endPlain]
|
|
# Adjust range end
|
|
z = z - len(document.body[arg : argend + 1])
|
|
# Remove arg inset
|
|
del document.body[arg : argend + 1]
|
|
pre += put_cmd_in_ert("<") + argcontent + put_cmd_in_ert(">")
|
|
arg = find_token(document.body, "\\begin_inset Argument 2", i, z)
|
|
if arg != -1:
|
|
argend = find_end_of_inset(document.body, arg)
|
|
if argend == -1:
|
|
document.warning("Can't find end of Argument!")
|
|
i += 1
|
|
continue
|
|
# Find containing paragraph layout
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", arg)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
argcontent = document.body[beginPlain + 1 : endPlain]
|
|
# Adjust range end
|
|
z = z - len(document.body[arg : argend + 1])
|
|
# Remove arg inset
|
|
del document.body[arg : argend + 1]
|
|
pre += put_cmd_in_ert("[") + argcontent + put_cmd_in_ert("]")
|
|
pre += put_cmd_in_ert("{")
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", i)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
# Adjust range end
|
|
z = z - len(document.body[i : beginPlain + 1])
|
|
z += len(pre)
|
|
document.body[i : beginPlain + 1] = pre
|
|
post = put_cmd_in_ert("}")
|
|
document.body[z - 2 : z + 1] = post
|
|
elif flextype in old_flexes:
|
|
pre = put_cmd_in_ert(old_flexes[flextype])
|
|
arg = find_token(document.body, "\\begin_inset Argument 1", i, z)
|
|
if arg == -1:
|
|
i += 1
|
|
continue
|
|
argend = find_end_of_inset(document.body, arg)
|
|
if argend == -1:
|
|
document.warning("Can't find end of Argument!")
|
|
i += 1
|
|
continue
|
|
# Find containing paragraph layout
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", arg)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
argcontent = document.body[beginPlain + 1 : endPlain]
|
|
# Adjust range end
|
|
z = z - len(document.body[arg : argend + 1])
|
|
# Remove arg inset
|
|
del document.body[arg : argend + 1]
|
|
pre += put_cmd_in_ert("<") + argcontent + put_cmd_in_ert(">")
|
|
pre += put_cmd_in_ert("{")
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", i)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
# Adjust range end
|
|
z = z - len(document.body[i : beginPlain + 1])
|
|
z += len(pre)
|
|
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
|
|
|
|
blocks = ["Block", "ExampleBlock", "AlertBlock"]
|
|
|
|
rx = re.compile(r'^\\begin_inset Argument (\S+)$')
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, "\\begin_inset Argument", i)
|
|
if i == -1:
|
|
return
|
|
# Find containing paragraph layout
|
|
parent = get_containing_layout(document.body, i)
|
|
if parent == False:
|
|
document.warning("Malformed lyx document: Can't find parent paragraph layout")
|
|
i = i + 1
|
|
continue
|
|
parbeg = parent[1]
|
|
parend = parent[2]
|
|
realparbeg = parent[3]
|
|
layoutname = parent[0]
|
|
realparend = parend
|
|
for p in range(parbeg, parend):
|
|
if p >= realparend:
|
|
i = realparend
|
|
break
|
|
if layoutname in blocks:
|
|
m = rx.match(document.body[p])
|
|
if m:
|
|
argnr = m.group(1)
|
|
if argnr == "1":
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", p)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
endInset = find_end_of_inset(document.body, p)
|
|
content = document.body[beginPlain + 1 : endPlain]
|
|
# Adjust range end
|
|
realparend = realparend - len(document.body[p : endInset + 1])
|
|
# Remove arg inset
|
|
del document.body[p : endInset + 1]
|
|
subst = put_cmd_in_ert("<") + content + put_cmd_in_ert(">")
|
|
document.body[realparbeg : realparbeg] = subst
|
|
elif argnr == "2":
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", p)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
endInset = find_end_of_inset(document.body, p)
|
|
content = document.body[beginPlain + 1 : endPlain]
|
|
# Adjust range end
|
|
realparend = realparend - len(document.body[p : endInset + 1])
|
|
# Remove arg inset
|
|
del document.body[p : endInset + 1]
|
|
subst = put_cmd_in_ert("{") + content + put_cmd_in_ert("}")
|
|
document.body[realparbeg : realparbeg] = subst
|
|
i = realparend
|
|
|
|
|
|
|
|
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
|
|
while True:
|
|
i = find_token_exact(document.body, "\\begin_layout " + lay, i)
|
|
if i == -1:
|
|
break
|
|
parent = get_containing_layout(document.body, i)
|
|
if parent == False or parent[1] != i:
|
|
document.warning("Wrong parent layout!")
|
|
i += 1
|
|
continue
|
|
j = parent[2]
|
|
parbeg = parent[3]
|
|
if i != -1:
|
|
if document.body[parbeg] == "\\begin_inset ERT":
|
|
ertcont = parbeg + 5
|
|
while True:
|
|
if document.body[ertcont].startswith("<"):
|
|
# This is an overlay specification
|
|
# strip off the <
|
|
document.body[ertcont] = document.body[ertcont][1:]
|
|
if document.body[ertcont].endswith(">"):
|
|
# strip off the >
|
|
document.body[ertcont] = document.body[ertcont][:-1]
|
|
# Convert to ArgInset
|
|
document.body[parbeg] = "\\begin_inset Argument 1"
|
|
elif document.body[ertcont].endswith("}"):
|
|
# divide the args
|
|
tok = document.body[ertcont].find('>{')
|
|
if tok != -1:
|
|
document.body[ertcont : ertcont + 1] = [document.body[ertcont][:tok],
|
|
'\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 2',
|
|
'status collapsed', '', '\\begin_layout Plain Layout',
|
|
document.body[ertcont][tok + 2:-1]]
|
|
# Convert to ArgInset
|
|
document.body[parbeg] = "\\begin_inset Argument 1"
|
|
elif document.body[ertcont].startswith("{"):
|
|
# This is the block title
|
|
if document.body[ertcont].endswith("}"):
|
|
# strip off the braces
|
|
document.body[ertcont] = document.body[ertcont][1:-1]
|
|
# Convert to ArgInset
|
|
document.body[parbeg] = "\\begin_inset Argument 2"
|
|
elif count_pars_in_inset(document.body, ertcont) > 1:
|
|
# Multipar ERT. Skip this.
|
|
break
|
|
else:
|
|
convert_TeX_brace_to_Argument(document, i, 2, 2, False, True)
|
|
else:
|
|
break
|
|
j = find_end_of_layout(document.body, i)
|
|
if j == -1:
|
|
document.warning("end of layout not found!")
|
|
k = find_token(document.body, "\\begin_inset Argument", i, j)
|
|
if k == -1:
|
|
document.warning("InsetArgument not found!")
|
|
break
|
|
l = find_end_of_inset(document.body, k)
|
|
m = find_token(document.body, "\\begin_inset ERT", l, j)
|
|
if m == -1:
|
|
break
|
|
ertcont = m + 5
|
|
parbeg = m
|
|
i = j
|
|
|
|
|
|
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
|
|
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, "\\begin_layout Overprint", i)
|
|
if i == -1:
|
|
return
|
|
# Find end of sequence
|
|
j = find_end_of_sequence(document.body, i)
|
|
if j == -1:
|
|
document.warning("Malformed lyx document. Cannot find end of Overprint sequence!")
|
|
i = i + 1
|
|
continue
|
|
endseq = j
|
|
subst = ["\\begin_layout Standard"] + put_cmd_in_ert("\\begin{overprint}")
|
|
esubst = list()
|
|
if document.body[j] == "\\end_deeper":
|
|
esubst = ["", "\\begin_layout Standard"] + put_cmd_in_ert("\\end{overprint}") + ["\\end_layout"]
|
|
else:
|
|
esubst = ["\\end_layout", "", "\\begin_layout Standard"] + put_cmd_in_ert("\\end{overprint}") + ["\\end_layout"]
|
|
endseq = endseq + len(esubst) - len(document.body[j : j])
|
|
document.body[j : j] = esubst
|
|
argbeg = find_token(document.body, "\\begin_inset Argument 1", i, j)
|
|
if argbeg != -1:
|
|
argend = find_end_of_layout(document.body, argbeg)
|
|
if argend == -1:
|
|
document.warning("Malformed lyx document. Cannot find end of Overprint argument!")
|
|
i = 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 + 1])
|
|
# 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"
|
|
|
|
i = endseq
|
|
|
|
|
|
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
|
|
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, "\\begin_layout Overprint", i)
|
|
if i == -1:
|
|
return
|
|
# Find end of sequence
|
|
j = find_end_of_sequence(document.body, i)
|
|
if j == -1:
|
|
document.warning("Malformed lyx document. Cannot find end of Overprint sequence!")
|
|
i = i + 1
|
|
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}")
|
|
endseq = endseq + len(esubst) - len(document.body[j : j])
|
|
document.body[j : j] = esubst
|
|
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 = 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"]
|
|
endseq += len(subst)
|
|
|
|
p = i
|
|
while True:
|
|
if p >= endseq:
|
|
break
|
|
if document.body[p] == "\\begin_layout Overprint":
|
|
q = find_end_of_layout(document.body, p)
|
|
if q == -1:
|
|
document.warning("Malformed lyx document. Cannot find end of Overprint layout!")
|
|
p += 1
|
|
continue
|
|
subst = ["\\begin_layout Standard"] + put_cmd_in_ert("\\onslide")
|
|
argbeg = find_token(document.body, "\\begin_inset Argument item:1", p, q)
|
|
if argbeg != -1:
|
|
argend = find_end_of_inset(document.body, argbeg)
|
|
if argend == -1:
|
|
document.warning("Malformed lyx document. Cannot find end of Overprint item argument!")
|
|
p += 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 + 1])
|
|
# Remove arg inset
|
|
del document.body[argbeg : argend + 1]
|
|
subst += put_cmd_in_ert("<") + content + put_cmd_in_ert(">")
|
|
endseq = endseq - len(document.body[p : p + 1]) + len(subst)
|
|
document.body[p : p + 1] = subst
|
|
p = p + 1
|
|
|
|
i = 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
|
|
|
|
rx = re.compile(r'^\\begin_inset Argument (\S+)$')
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, "\\begin_layout FrameTitle", 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 FrameTitle layout")
|
|
i = i + 1
|
|
continue
|
|
endlay = j
|
|
document.body[j : j] = put_cmd_in_ert("}") + document.body[j : j]
|
|
endlay += len(put_cmd_in_ert("}"))
|
|
subst = ["\\begin_layout Standard"] + put_cmd_in_ert("\\frametitle")
|
|
for p in range(i, j):
|
|
if p >= endlay:
|
|
break
|
|
m = rx.match(document.body[p])
|
|
if m:
|
|
argnr = m.group(1)
|
|
if argnr == "1":
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", p)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
endInset = find_end_of_inset(document.body, p)
|
|
content = document.body[beginPlain + 1 : endPlain]
|
|
# Adjust range end
|
|
endlay = endlay - len(document.body[p : endInset + 1])
|
|
# Remove arg inset
|
|
del document.body[p : endInset + 1]
|
|
subst += put_cmd_in_ert("<") + content + put_cmd_in_ert(">")
|
|
elif argnr == "2":
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", p)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
endInset = find_end_of_inset(document.body, p)
|
|
content = document.body[beginPlain + 1 : endPlain]
|
|
# Adjust range end
|
|
endlay = endlay - len(document.body[p : endInset + 1])
|
|
# 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
|
|
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, "\\begin_layout Epigraph", 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 Epigraph layout")
|
|
i = i + 1
|
|
continue
|
|
endlay = j
|
|
subst = list()
|
|
ert = find_token(document.body, "\\begin_inset ERT", i, j)
|
|
if ert != -1:
|
|
endInset = find_end_of_inset(document.body, ert)
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", ert)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
ertcont = beginPlain + 2
|
|
if document.body[ertcont] == "}{":
|
|
# strip off the <
|
|
# Convert to ArgInset
|
|
endlay = endlay - 2 * len(document.body[j])
|
|
begsubst = ['\\begin_inset Argument post:1', 'status collapsed', '',
|
|
'\\begin_layout Plain Layout']
|
|
endsubst = ['\\end_layout', '', '\\end_inset', '', document.body[j]]
|
|
document.body[j : j + 1] = endsubst
|
|
document.body[endInset + 1 : endInset + 1] = begsubst
|
|
# Adjust range end
|
|
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
|
|
|
|
i = 0
|
|
while True:
|
|
i = find_token(document.body, "\\begin_layout Epigraph", 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 Epigraph layout")
|
|
i = i + 1
|
|
continue
|
|
endlay = j
|
|
subst = list()
|
|
p = find_token(document.body, "\\begin_layout Argument post:1", i, j)
|
|
if p != -1:
|
|
beginPlain = find_token(document.body, "\\begin_layout Plain Layout", p)
|
|
endPlain = find_end_of_layout(document.body, beginPlain)
|
|
endInset = find_end_of_inset(document.body, p)
|
|
content = document.body[beginPlain + 1 : endPlain]
|
|
# Adjust range end
|
|
endlay = endlay - len(document.body[p : endInset + 1])
|
|
# Remove arg inset
|
|
del document.body[p : endInset + 1]
|
|
subst += put_cmd_in_ert("}{") + content
|
|
else:
|
|
subst += put_cmd_in_ert("}{")
|
|
|
|
document.body[j : j] = subst + document.body[j : j]
|
|
i = endlay
|
|
|
|
|
|
##
|
|
# Conversion hub
|
|
#
|
|
|
|
supported_versions = ["2.1.0","2.1"]
|
|
convert = [
|
|
[414, []],
|
|
[415, [convert_undertilde]],
|
|
[416, []],
|
|
[417, [convert_japanese_encodings]],
|
|
[418, []],
|
|
[419, []],
|
|
[420, [convert_biblio_style]],
|
|
[421, [convert_longtable_captions]],
|
|
[422, [convert_use_packages]],
|
|
[423, [convert_use_mathtools]],
|
|
[424, [convert_cite_engine_type]],
|
|
[425, []],
|
|
[426, []],
|
|
[427, []],
|
|
[428, [convert_cell_rotation]],
|
|
[429, [convert_table_rotation]],
|
|
[430, [convert_listoflistings]],
|
|
[431, [convert_use_amssymb]],
|
|
[432, []],
|
|
[433, [convert_armenian]],
|
|
[434, []],
|
|
[435, []],
|
|
[436, []],
|
|
[437, []],
|
|
[438, []],
|
|
[439, []],
|
|
[440, []],
|
|
[441, [convert_mdnomath]],
|
|
[442, []],
|
|
[443, []],
|
|
[444, []],
|
|
[445, []],
|
|
[446, [convert_latexargs]],
|
|
[447, [convert_IEEEtran, convert_AASTeX, convert_AGUTeX, convert_IJMP, convert_SIGPLAN, convert_SIGGRAPH, convert_EuropeCV]],
|
|
[448, [convert_literate]],
|
|
[449, []],
|
|
[450, []],
|
|
[451, [convert_beamerargs, convert_againframe_args, convert_corollary_args, convert_quote_args]],
|
|
[452, [convert_beamerblocks]],
|
|
[453, [convert_use_stmaryrd]],
|
|
[454, [convert_overprint]],
|
|
[455, []],
|
|
[456, [convert_epigraph]]
|
|
]
|
|
|
|
revert = [
|
|
[455, [revert_epigraph]],
|
|
[454, [revert_frametitle]],
|
|
[453, [revert_overprint]],
|
|
[452, [revert_use_stmaryrd]],
|
|
[451, [revert_beamerblocks]],
|
|
[450, [revert_beamerargs, revert_beamerargs2, revert_beamerargs3, revert_beamerflex]],
|
|
[449, [revert_garamondx, revert_garamondx_newtxmath]],
|
|
[448, [revert_itemargs]],
|
|
[447, [revert_literate]],
|
|
[446, [revert_IEEEtran, revert_AASTeX, revert_AGUTeX, revert_IJMP, revert_SIGPLAN, revert_SIGGRAPH, revert_EuropeCV]],
|
|
[445, [revert_latexargs]],
|
|
[444, [revert_uop]],
|
|
[443, [revert_biolinum]],
|
|
[442, []],
|
|
[441, [revert_newtxmath]],
|
|
[440, [revert_mdnomath]],
|
|
[439, [revert_mathfonts]],
|
|
[438, [revert_minionpro]],
|
|
[437, [revert_ipadeco, revert_ipachar]],
|
|
[436, [revert_texgyre]],
|
|
[435, [revert_mathdesign]],
|
|
[434, [revert_txtt]],
|
|
[433, [revert_libertine]],
|
|
[432, [revert_armenian]],
|
|
[431, [revert_languages, revert_ancientgreek]],
|
|
[430, [revert_use_amssymb]],
|
|
[429, [revert_listoflistings]],
|
|
[428, [revert_table_rotation]],
|
|
[427, [revert_cell_rotation]],
|
|
[426, [revert_tipa]],
|
|
[425, [revert_verbatim]],
|
|
[424, [revert_cancel]],
|
|
[423, [revert_cite_engine_type]],
|
|
[422, [revert_use_mathtools]],
|
|
[421, [revert_use_packages]],
|
|
[420, [revert_longtable_captions]],
|
|
[419, [revert_biblio_style]],
|
|
[418, [revert_australian]],
|
|
[417, [revert_justification]],
|
|
[416, [revert_japanese_encodings]],
|
|
[415, [revert_negative_space, revert_math_spaces]],
|
|
[414, [revert_undertilde]],
|
|
[413, [revert_visible_space]]
|
|
]
|
|
|
|
|
|
if __name__ == "__main__":
|
|
pass
|