X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=lib%2Flyx2lyx%2Flyx_2_4.py;h=3fd876c826797d3c3f906e59117fba09c8104f59;hb=d0a27e3afc3444d10694df10dc4cb8d604287765;hp=08490576558e30a73234b7ef54fafc7247278cad;hpb=cb5bd87e9c16f3dc1a774ece4f78d7c63cc4c645;p=lyx.git diff --git a/lib/lyx2lyx/lyx_2_4.py b/lib/lyx2lyx/lyx_2_4.py index 0849057655..3fd876c826 100644 --- a/lib/lyx2lyx/lyx_2_4.py +++ b/lib/lyx2lyx/lyx_2_4.py @@ -47,7 +47,7 @@ from lyx2lyx_tools import (put_cmd_in_ert, add_to_preamble, insert_to_preamble, # Private helper functions def add_preamble_fonts(document, fontmap): - " Add collected font-packages with their option to user-preamble" + """Add collected font-packages with their option to user-preamble""" for pkg in fontmap: if len(fontmap[pkg]) > 0: @@ -72,6 +72,8 @@ class fontinfo: self.package = None self.options = [] self.pkgkey = None # key into pkg2fontmap + self.osfopt = None # None, string + self.osfdef = "false" # "false" or "true" def addkey(self): self.pkgkey = createkey(self.package, self.options) @@ -82,8 +84,8 @@ class fontmapping: self.pkg2fontmap = dict() self.pkginmap = dict() # defines, if a map for package exists - def expandFontMapping(self, font_list, font_type, scale_type, pkg, scaleopt = None): - " Expand fontinfo mapping" + def expandFontMapping(self, font_list, font_type, scale_type, pkg, scaleopt = None, osfopt = None, osfdef = "false"): + """Expand fontinfo mapping""" # # fontlist: list of fontnames, each element # may contain a ','-separated list of needed options @@ -93,6 +95,8 @@ class fontmapping: # pkg: package defining the font. Defaults to fontname if None # scaleopt: one of None, 'scale', 'scaled', or some other string # to be used in scale option (e.g. scaled=0.7) + # osfopt: None or some other string to be used in osf option + # osfdef: "true" if osf is default for fl in font_list: fe = fontinfo() fe.fonttype = font_type @@ -102,6 +106,8 @@ class fontmapping: fe.fontname = font_name fe.options = flt[1:] fe.scaleopt = scaleopt + fe.osfopt = osfopt + fe.osfdef = osfdef if pkg == None: fe.package = font_name else: @@ -157,29 +163,52 @@ def createFontMapping(fontlist): 'IBMPlexMonoSemibold,semibold'], "typewriter", "tt", "plex-mono", "scale") elif font == 'Adobe': - fm.expandFontMapping(['ADOBESourceSerifPro'], "roman", None, "sourceserifpro") - fm.expandFontMapping(['ADOBESourceSansPro'], "sans", "sf", "sourcesanspro", "scaled") - fm.expandFontMapping(['ADOBESourceCodePro'], "typewriter", "tt", "sourcecodepro", "scaled") + fm.expandFontMapping(['ADOBESourceSerifPro'], "roman", None, "sourceserifpro", None, "osf") + fm.expandFontMapping(['ADOBESourceSansPro'], "sans", "sf", "sourcesanspro", "scaled", "osf") + fm.expandFontMapping(['ADOBESourceCodePro'], "typewriter", "tt", "sourcecodepro", "scaled", "osf") elif font == 'Noto': fm.expandFontMapping(['NotoSerifRegular,regular', 'NotoSerifMedium,medium', 'NotoSerifThin,thin', 'NotoSerifLight,light', 'NotoSerifExtralight,extralight'], - "roman", None, "noto-serif") + "roman", None, "noto-serif", None, "osf") fm.expandFontMapping(['NotoSansRegular,regular', 'NotoSansMedium,medium', 'NotoSansThin,thin', 'NotoSansLight,light', 'NotoSansExtralight,extralight'], "sans", "sf", "noto-sans", "scaled") - fm.expandFontMapping(['NotoMonoRegular'], "typewriter", "tt", "noto-mono", "scaled") + fm.expandFontMapping(['NotoMonoRegular,regular'], "typewriter", "tt", "noto-mono", "scaled") + elif font == 'Cantarell': + fm.expandFontMapping(['cantarell,defaultsans'], + "sans", "sf", "cantarell", "scaled", "oldstyle") + elif font == 'Chivo': + fm.expandFontMapping(['ChivoThin,thin', 'ChivoLight,light', + 'Chivo,regular', 'ChivoMedium,medium'], + "sans", "sf", "Chivo", "scale", "oldstyle") + elif font == 'CrimsonPro': + fm.expandFontMapping(['CrimsonPro', 'CrimsonProExtraLight,extralight', 'CrimsonProLight,light', + 'CrimsonProMedium,medium'], + "roman", None, "CrimsonPro", None, "lf", "true") + elif font == 'Fira': + fm.expandFontMapping(['FiraSans', 'FiraSansBook,book', + 'FiraSansThin,thin', 'FiraSansLight,light', + 'FiraSansExtralight,extralight', + 'FiraSansUltralight,ultralight'], + "sans", "sf", "FiraSans", "scaled", "lf", "true") + fm.expandFontMapping(['FiraMono'], "typewriter", "tt", "FiraMono", "scaled", "lf", "true") + elif font == 'libertinus': + fm.expandFontMapping(['libertinus,serif'], "roman", None, "libertinus", None, "osf") + fm.expandFontMapping(['libertinusmath'], "math", None, "libertinust1math", None, None) return fm -def convert_fonts(document, fm): - " Handle font definition (LaTeX preamble -> native) " - +def convert_fonts(document, fm, osfoption = "osf"): + """Handle font definition (LaTeX preamble -> native)""" rpkg = re.compile(r'^\\usepackage(\[([^\]]*)\])?\{([^\}]+)\}') rscaleopt = re.compile(r'^scaled?=(.*)') + # Check whether we go beyond font option feature introduction + haveFontOpts = document.end_format > 580 + i = 0 - while i < len(document.preamble): + while True: i = find_re(document.preamble, rpkg, i+1) if i == -1: return @@ -191,19 +220,40 @@ def convert_fonts(document, fm): pkg = mo.group(3) o = 0 oscale = 1 + has_osf = False while o < len(options): + if options[o] == osfoption: + has_osf = True + del options[o] + continue mo = rscaleopt.search(options[o]) if mo == None: o += 1 continue oscale = mo.group(1) del options[o] - break + continue if not pkg in fm.pkginmap: continue # determine fontname - fn = fm.getfontname(pkg, options) + fn = None + if haveFontOpts: + # Try with name-option combination first + # (only one default option supported currently) + o = 0 + while o < len(options): + opt = options[o] + fn = fm.getfontname(pkg, [opt]) + if fn != None: + del options[o] + break + o += 1 + continue + if fn == None: + fn = fm.getfontname(pkg, []) + else: + fn = fm.getfontname(pkg, options) if fn == None: continue del document.preamble[i] @@ -213,7 +263,18 @@ def convert_fonts(document, fm): else: fontscale = "\\font_" + fontinfo.scaletype + "_scale" fontinfo.scaleval = oscale - + if (has_osf and fontinfo.osfdef == "false") or (not has_osf and fontinfo.osfdef == "true"): + if fontinfo.osfopt == None: + options.extend(osfoption) + continue + osf = find_token(document.header, "\\font_osf false") + osftag = "\\font_osf" + if osf == -1 and fontinfo.fonttype != "math": + # Try with newer format + osftag = "\\font_" + fontinfo.fonttype + "_osf" + osf = find_token(document.header, osftag + " false") + if osf != -1: + document.header[osf] = osftag + " true" if i > 0 and document.preamble[i-1] == "% Added by lyx2lyx": del document.preamble[i-1] i -= 1 @@ -233,9 +294,22 @@ def convert_fonts(document, fm): words = val.split() # ! splits also values like '"DejaVu Sans"' words[0] = '"' + fn + '"' document.header[j] = ft + ' ' + ' '.join(words) + if haveFontOpts and fontinfo.fonttype != "math": + fotag = "\\font_" + fontinfo.fonttype + "_opts" + fo = find_token(document.header, fotag) + if fo != -1: + document.header[fo] = fotag + " \"" + ",".join(options) + "\"" + else: + # Sensible place to insert tag + fo = find_token(document.header, "\\font_sf_scale") + if fo == -1: + document.warning("Malformed LyX document! Missing \\font_sf_scale") + else: + document.header.insert(fo, fotag + " \"" + ",".join(options) + "\"") + -def revert_fonts(document, fm, fontmap): - " Revert native font definition to LaTeX " +def revert_fonts(document, fm, fontmap, OnlyWithXOpts = False, WithXOpts = False): + """Revert native font definition to LaTeX""" # fonlist := list of fonts created from the same package # Empty package means that the font-name is the same as the package-name # fontmap (key = package, val += found options) will be filled @@ -247,7 +321,7 @@ def revert_fonts(document, fm, fontmap): while i < len(document.header): i = find_re(document.header, rfontscale, i+1) if (i == -1): - break + return True mo = rfontscale.search(document.header[i]) if mo == None: continue @@ -261,6 +335,25 @@ def revert_fonts(document, fm, fontmap): val = fontinfo.package if not val in fontmap: fontmap[val] = [] + x = -1 + if OnlyWithXOpts or WithXOpts: + if ft == "\\font_math": + return False + regexp = re.compile(r'^\s*(\\font_roman_opts)\s+') + if ft == "\\font_sans": + regexp = re.compile(r'^\s*(\\font_sans_opts)\s+') + elif ft == "\\font_typewriter": + regexp = re.compile(r'^\s*(\\font_typewriter_opts)\s+') + x = find_re(document.header, regexp, 0) + if x == -1 and OnlyWithXOpts: + return False + + if x != -1: + # We need to use this regex since split() does not handle quote protection + xopts = re.findall(r'[^"\s]\S*|".+?"', document.header[x]) + opts = xopts[1].strip('"').split(",") + fontmap[val].extend(opts) + del document.header[x] words[0] = '"default"' document.header[i] = ft + ' ' + ' '.join(words) if fontinfo.scaleopt != None: @@ -272,8 +365,24 @@ def revert_fonts(document, fm, fontmap): if xval1 != "100": # set correct scale option fontmap[val].extend([fontinfo.scaleopt + "=" + format(float(xval1) / 100, '.2f')]) + if fontinfo.osfopt != None: + oldval = "true" + if fontinfo.osfdef == "true": + oldval = "false" + osf = find_token(document.header, "\\font_osf " + oldval) + if osf == -1 and ft != "\\font_math": + # Try with newer format + osftag = "\\font_roman_osf " + oldval + if ft == "\\font_sans": + osftag = "\\font_sans_osf " + oldval + elif ft == "\\font_typewriter": + osftag = "\\font_typewriter_osf " + oldval + osf = find_token(document.header, osftag) + if osf != -1: + fontmap[val].extend([fontinfo.osfopt]) if len(fontinfo.options) > 0: fontmap[val].extend(fontinfo.options) + return True ############################################################################### ### @@ -282,7 +391,7 @@ def revert_fonts(document, fm, fontmap): ############################################################################### def convert_inputencoding_namechange(document): - " Rename inputencoding settings. " + """Rename inputencoding settings.""" i = find_token(document.header, "\\inputencoding", 0) if i == -1: return @@ -290,7 +399,7 @@ def convert_inputencoding_namechange(document): document.header[i] = s.replace("default", "auto-legacy-plain") def revert_inputencoding_namechange(document): - " Rename inputencoding settings. " + """Rename inputencoding settings.""" i = find_token(document.header, "\\inputencoding", 0) if i == -1: return @@ -298,55 +407,55 @@ def revert_inputencoding_namechange(document): document.header[i] = s.replace("auto-legacy", "auto") def convert_notoFonts(document): - " Handle Noto fonts definition to LaTeX " + """Handle Noto fonts definition to LaTeX""" - if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: + if not get_bool_value(document.header, "\\use_non_tex_fonts"): fm = createFontMapping(['Noto']) convert_fonts(document, fm) def revert_notoFonts(document): - " Revert native Noto font definition to LaTeX " + """Revert native Noto font definition to LaTeX""" - if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: + if not get_bool_value(document.header, "\\use_non_tex_fonts"): fontmap = dict() fm = createFontMapping(['Noto']) - revert_fonts(document, fm, fontmap) - add_preamble_fonts(document, fontmap) + if revert_fonts(document, fm, fontmap): + add_preamble_fonts(document, fontmap) def convert_latexFonts(document): - " Handle DejaVu and IBMPlex fonts definition to LaTeX " + """Handle DejaVu and IBMPlex fonts definition to LaTeX""" - if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: + if not get_bool_value(document.header, "\\use_non_tex_fonts"): fm = createFontMapping(['DejaVu', 'IBM']) convert_fonts(document, fm) def revert_latexFonts(document): - " Revert native DejaVu font definition to LaTeX " + """Revert native DejaVu font definition to LaTeX""" - if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: + if not get_bool_value(document.header, "\\use_non_tex_fonts"): fontmap = dict() fm = createFontMapping(['DejaVu', 'IBM']) - revert_fonts(document, fm, fontmap) - add_preamble_fonts(document, fontmap) + if revert_fonts(document, fm, fontmap): + add_preamble_fonts(document, fontmap) def convert_AdobeFonts(document): - " Handle DejaVu and IBMPlex fonts definition to LaTeX " + """Handle Adobe Source fonts definition to LaTeX""" - if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: + if not get_bool_value(document.header, "\\use_non_tex_fonts"): fm = createFontMapping(['Adobe']) convert_fonts(document, fm) def revert_AdobeFonts(document): - " Revert native DejaVu font definition to LaTeX " + """Revert Adobe Source font definition to LaTeX""" - if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: + if not get_bool_value(document.header, "\\use_non_tex_fonts"): fontmap = dict() fm = createFontMapping(['Adobe']) - revert_fonts(document, fm, fontmap) - add_preamble_fonts(document, fontmap) + if revert_fonts(document, fm, fontmap): + add_preamble_fonts(document, fontmap) def removeFrontMatterStyles(document): - " Remove styles Begin/EndFrontmatter" + """Remove styles Begin/EndFrontmatter""" layouts = ['BeginFrontmatter', 'EndFrontmatter'] tokenend = len('\\begin_layout ') @@ -367,7 +476,7 @@ def removeFrontMatterStyles(document): document.body[i:j+1] = [] def addFrontMatterStyles(document): - " Use styles Begin/EndFrontmatter for elsarticle" + """Use styles Begin/EndFrontmatter for elsarticle""" if document.textclass != "elsarticle": return @@ -414,7 +523,7 @@ def addFrontMatterStyles(document): def convert_lst_literalparam(document): - " Add param literal to include inset " + """Add param literal to include inset""" i = 0 while True: @@ -431,7 +540,7 @@ def convert_lst_literalparam(document): def revert_lst_literalparam(document): - " Remove param literal from include inset " + """Remove param literal from include inset""" i = 0 while True: @@ -446,20 +555,33 @@ def revert_lst_literalparam(document): def revert_paratype(document): - " Revert ParaType font definitions to LaTeX " + """Revert ParaType font definitions to LaTeX""" - if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: + if not get_bool_value(document.header, "\\use_non_tex_fonts"): preamble = "" i1 = find_token(document.header, "\\font_roman \"PTSerif-TLF\"", 0) i2 = find_token(document.header, "\\font_sans \"default\"", 0) i3 = find_token(document.header, "\\font_typewriter \"default\"", 0) j = find_token(document.header, "\\font_sans \"PTSans-TLF\"", 0) - sfval = get_value(document.header, "\\font_sf_scale", 0) - # cutoff " 100" - sfval = sfval[:-4] + + sf_scale = 100.0 + sfval = find_token(document.header, "\\font_sf_scale", 0) + if sfval == -1: + document.warning("Malformed LyX document: Missing \\font_sf_scale.") + else: + sfscale = document.header[sfval].split() + val = sfscale[1] + sfscale[1] = "100" + document.header[sfval] = " ".join(sfscale) + try: + # float() can throw + sf_scale = float(val) + except: + document.warning("Invalid font_sf_scale value: " + val) + sfoption = "" - if sfval != "100": - sfoption = "scaled=" + format(float(sfval) / 100, '.2f') + if sf_scale != "100.0": + sfoption = "scaled=" + str(sf_scale / 100.0) k = find_token(document.header, "\\font_typewriter \"PTMono-TLF\"", 0) ttval = get_value(document.header, "\\font_tt_scale", 0) # cutoff " 100" @@ -488,7 +610,7 @@ def revert_paratype(document): def revert_xcharter(document): - " Revert XCharter font definitions to LaTeX " + """Revert XCharter font definitions to LaTeX""" i = find_token(document.header, "\\font_roman \"xcharter\"", 0) if i == -1: @@ -512,7 +634,7 @@ def revert_xcharter(document): def revert_lscape(document): - " Reverts the landscape environment (Landscape module) to TeX-code " + """Reverts the landscape environment (Landscape module) to TeX-code""" if not "landscape" in document.get_module_list(): return @@ -521,7 +643,7 @@ def revert_lscape(document): while True: i = find_token(document.body, "\\begin_inset Flex Landscape", i+1) if i == -1: - return + break j = find_end_of_inset(document.body, i) if j == -1: document.warning("Malformed LyX document: Can't find end of Landscape inset") @@ -536,10 +658,11 @@ def revert_lscape(document): document.body[i : i + 4] = put_cmd_in_ert("\\begin{landscape}") add_to_preamble(document, ["\\usepackage{pdflscape}"]) + document.del_module("landscape") def convert_fontenc(document): - " Convert default fontenc setting " + """Convert default fontenc setting""" i = find_token(document.header, "\\fontencoding global", 0) if i == -1: @@ -549,7 +672,7 @@ def convert_fontenc(document): def revert_fontenc(document): - " Revert default fontenc setting " + """Revert default fontenc setting""" i = find_token(document.header, "\\fontencoding auto", 0) if i == -1: @@ -559,7 +682,7 @@ def revert_fontenc(document): def revert_nospellcheck(document): - " Remove nospellcheck font info param " + """Remove nospellcheck font info param""" i = 0 while True: @@ -570,19 +693,19 @@ def revert_nospellcheck(document): def revert_floatpclass(document): - " Remove float placement params 'document' and 'class' " + """Remove float placement params 'document' and 'class'""" del_token(document.header, "\\float_placement class") i = 0 while True: - i = find_token(document.body, '\\begin_inset Float', i+1) + i = find_token(document.body, '\\begin_inset Float', i + 1) if i == -1: break j = find_end_of_inset(document.body, i) - k = find_token(document.body, 'placement class', i, i + 2) + k = find_token(document.body, 'placement class', i, j) if k == -1: - k = find_token(document.body, 'placement document', i, i + 2) + k = find_token(document.body, 'placement document', i, j) if k != -1: del document.body[k] continue @@ -590,20 +713,20 @@ def revert_floatpclass(document): def revert_floatalignment(document): - " Remove float alignment params " + """Remove float alignment params""" galignment = get_value(document.header, "\\float_alignment", delete=True) i = 0 while True: - i = find_token(document.body, '\\begin_inset Float', i+1) + i = find_token(document.body, '\\begin_inset Float', i + 1) if i == -1: break j = find_end_of_inset(document.body, i) if j == -1: document.warning("Malformed LyX document: Can't find end of inset at line " + str(i)) continue - k = find_token(document.body, 'alignment', i, i+4) + k = find_token(document.body, 'alignment', i, j) if k == -1: i = j continue @@ -624,10 +747,12 @@ def revert_floatalignment(document): alcmd = put_cmd_in_ert("\\raggedleft{}") if len(alcmd) > 0: document.body[l+1:l+1] = alcmd - i = j + # There might be subfloats, so we do not want to move past + # the end of the inset. + i += 1 def revert_tuftecite(document): - " Revert \cite commands in tufte classes " + """Revert \cite commands in tufte classes""" tufte = ["tufte-book", "tufte-handout"] if document.textclass not in tufte: @@ -670,8 +795,9 @@ def revert_tuftecite(document): i = j + def revert_stretchcolumn(document): - " We remove the column varwidth flags or everything else will become a mess. " + """We remove the column varwidth flags or everything else will become a mess.""" i = 0 while True: i = find_token(document.body, "\\begin_inset Tabular", i+1) @@ -688,7 +814,7 @@ def revert_stretchcolumn(document): def revert_vcolumns(document): - " Revert standard columns with line breaks etc. " + """Revert standard columns with line breaks etc.""" i = 0 needvarwidth = False needarray = False @@ -781,7 +907,7 @@ def revert_vcolumns(document): def revert_bibencoding(document): - " Revert bibliography encoding " + """Revert bibliography encoding""" # Get cite engine engine = "basic" @@ -880,7 +1006,7 @@ def revert_bibencoding(document): def convert_vcsinfo(document): - " Separate vcs Info inset from buffer Info inset. " + """Separate vcs Info inset from buffer Info inset.""" types = { "vcs-revision" : "revision", @@ -911,7 +1037,7 @@ def convert_vcsinfo(document): def revert_vcsinfo(document): - " Merge vcs Info inset to buffer Info inset. " + """Merge vcs Info inset to buffer Info inset.""" args = ["revision", "tree-revision", "author", "time", "date" ] i = 0 @@ -935,9 +1061,29 @@ def revert_vcsinfo(document): document.body[tp] = "type \"buffer\"" document.body[arg] = "arg \"vcs-" + argv + "\"" +def revert_vcsinfo_rev_abbrev(document): + " Convert abbreviated revisions to regular revisions. " + + i = 0 + while True: + i = find_token(document.body, "\\begin_inset Info", i+1) + if i == -1: + return + j = find_end_of_inset(document.body, i+1) + if j == -1: + document.warning("Malformed LyX document: Could not find end of Info inset.") + continue + tp = find_token(document.body, 'type', i, j) + tpv = get_quoted_value(document.body, "type", tp) + if tpv != "vcs": + continue + arg = find_token(document.body, 'arg', i, j) + argv = get_quoted_value(document.body, "arg", arg) + if( argv == "revision-abbrev" ): + document.body[arg] = "arg \"revision\"" def revert_dateinfo(document): - " Revert date info insets to static text. " + """Revert date info insets to static text.""" # FIXME This currently only considers the main language and uses the system locale # Ideally, it should honor context languages and switch the locale accordingly. @@ -1112,7 +1258,7 @@ def revert_dateinfo(document): def revert_timeinfo(document): - " Revert time info insets to static text. " + """Revert time info insets to static text.""" # FIXME This currently only considers the main language and uses the system locale # Ideally, it should honor context languages and switch the locale accordingly. @@ -1227,7 +1373,6 @@ def revert_timeinfo(document): } types = ["time", "fixtime", "modtime" ] - i = 0 i = find_token(document.header, "\\language", 0) if i == -1: # this should not happen @@ -1287,7 +1432,7 @@ def revert_timeinfo(document): def revert_namenoextinfo(document): - " Merge buffer Info inset type name-noext to name. " + """Merge buffer Info inset type name-noext to name.""" i = 0 while True: @@ -1310,7 +1455,7 @@ def revert_namenoextinfo(document): def revert_l7ninfo(document): - " Revert l7n Info inset to text. " + """Revert l7n Info inset to text.""" i = 0 while True: @@ -1333,7 +1478,7 @@ def revert_l7ninfo(document): def revert_listpargs(document): - " Reverts listpreamble arguments to TeX-code " + """Reverts listpreamble arguments to TeX-code""" i = 0 while True: i = find_token(document.body, "\\begin_inset Argument listpreamble:", i+1) @@ -1356,7 +1501,7 @@ def revert_listpargs(document): def revert_lformatinfo(document): - " Revert layout format Info inset to text. " + """Revert layout format Info inset to text.""" i = 0 while True: @@ -1400,19 +1545,19 @@ def convert_hebrew_parentheses(document): def revert_hebrew_parentheses(document): - " Store parentheses in Hebrew text reversed" + """Store parentheses in Hebrew text reversed""" # This only exists to keep the convert/revert naming convention convert_hebrew_parentheses(document) def revert_malayalam(document): - " Set the document language to English but assure Malayalam output " + """Set the document language to English but assure Malayalam output""" revert_language(document, "malayalam", "", "malayalam") def revert_soul(document): - " Revert soul module flex insets to ERT " + """Revert soul module flex insets to ERT""" flexes = ["Spaceletters", "Strikethrough", "Underline", "Highlight", "Capitalize"] @@ -1433,16 +1578,15 @@ def revert_soul(document): def revert_tablestyle(document): - " Remove tablestyle params " + """Remove tablestyle params""" - i = 0 i = find_token(document.header, "\\tablestyle") if i != -1: del document.header[i] def revert_bibfileencodings(document): - " Revert individual Biblatex bibliography encodings " + """Revert individual Biblatex bibliography encodings""" # Get cite engine engine = "basic" @@ -1550,7 +1694,7 @@ def revert_bibfileencodings(document): def revert_cmidruletrimming(document): - " Remove \\cmidrule trimming " + """Remove \\cmidrule trimming""" # FIXME: Revert to TeX code? i = 0 @@ -1606,19 +1750,21 @@ ruby_inset_def = [ r'End', ] + def convert_ruby_module(document): - " Use ruby module instead of local module definition " + """Use ruby module instead of local module definition""" if document.del_local_layout(ruby_inset_def): document.add_module("ruby") + def revert_ruby_module(document): - " Replace ruby module with local module definition " + """Replace ruby module with local module definition""" if document.del_module("ruby"): document.append_local_layout(ruby_inset_def) def convert_utf8_japanese(document): - " Use generic utf8 with Japanese documents." + """Use generic utf8 with Japanese documents.""" lang = get_value(document.header, "\\language") if not lang.startswith("japanese"): return @@ -1627,8 +1773,9 @@ def convert_utf8_japanese(document): or (lang == "japanese-cjk" and inputenc == "utf8-cjk")): document.set_parameter("inputencoding", "utf8") + def revert_utf8_japanese(document): - " Use Japanese utf8 variants with Japanese documents." + """Use Japanese utf8 variants with Japanese documents.""" inputenc = get_value(document.header, "\\inputencoding") if inputenc != "utf8": return @@ -1672,6 +1819,50 @@ def convert_lineno(document): "\\lineno_options %s" % options] +def convert_aaencoding(document): + " Convert default document option due to encoding change in aa class. " + + if document.textclass != "aa": + return + + i = find_token(document.header, "\\use_default_options true") + if i == -1: + return + val = get_value(document.header, "\\inputencoding") + if not val: + document.warning("Malformed LyX Document! Missing '\\inputencoding' header.") + return + if val == "auto-legacy" or val == "latin9": + document.header[i] = "\\use_default_options false" + k = find_token(document.header, "\\options") + if k == -1: + document.header.insert(i, "\\options latin9") + else: + document.header[k] += ",latin9" + + +def revert_aaencoding(document): + " Revert default document option due to encoding change in aa class. " + + if document.textclass != "aa": + return + + i = find_token(document.header, "\\use_default_options true") + if i == -1: + return + val = get_value(document.header, "\\inputencoding") + if not val: + document.warning("Malformed LyX Document! Missing \\inputencoding header.") + return + if val == "utf8": + document.header[i] = "\\use_default_options false" + k = find_token(document.header, "\\options", 0) + if k == -1: + document.header.insert(i, "\\options utf8") + else: + document.header[k] = document.header[k] + ",utf8" + + def revert_new_languages(document): """Emulate support for Azerbaijani, Bengali, Church Slavonic, Korean, and Russian (Petrine orthography).""" @@ -1683,26 +1874,27 @@ def revert_new_languages(document): "oldrussian": ("", "russian"), "korean": ("", "korean"), } - used_languages = set() if document.language in new_languages: - used_languages.add(document.language) + used_languages = set((document.language, )) + else: + used_languages = set() i = 0 while True: i = find_token(document.body, "\\lang", i+1) if i == -1: break - if document.body[i][6:].strip() in new_languages: - used_languages.add(document.language) + val = get_value(document.body, "\\lang", i) + if val in new_languages: + used_languages.add(val) # Korean is already supported via CJK, so leave as-is for Babel if ("korean" in used_languages - and get_bool_value(document.header, "\\use_non_tex_fonts") - and get_value(document.header, "\\language_package") in ("default", "auto")): - revert_language(document, "korean", "", "korean") - used_languages.discard("korean") + and (not get_bool_value(document.header, "\\use_non_tex_fonts") + or get_value(document.header, "\\language_package") == "babel")): + used_languages.discard("korean") for lang in used_languages: - revert(lang, *new_languages[lang]) + revert_language(document, lang, *new_languages[lang]) gloss_inset_def = [ @@ -1880,7 +2072,7 @@ def revert_linggloss(document): beginPlain = find_token(document.body, "\\begin_layout Plain Layout", i) endInset = find_end_of_inset(document.body, i) - endPlain = find_token_backwards(document.body, "\\end_layout", endInset) + endPlain = find_end_of_layout(document.body, beginPlain) precontent = put_cmd_in_ert(cmd) if len(optargcontent) > 0: precontent += put_cmd_in_ert("[") + optargcontent + put_cmd_in_ert("]") @@ -2176,12 +2368,9 @@ def revert_drs(document): def revert_babelfont(document): " Reverts the use of \\babelfont to user preamble " - i = find_token(document.header, '\\use_non_tex_fonts', 0) - if i == -1: - document.warning("Malformed LyX document: Missing \\use_non_tex_fonts.") - return - if not str2bool(get_value(document.header, "\\use_non_tex_fonts", i)): + if not get_bool_value(document.header, "\\use_non_tex_fonts"): return + i = find_token(document.header, '\\language_package', 0) if i == -1: document.warning("Malformed LyX document: Missing \\language_package.") @@ -2282,6 +2471,1495 @@ def revert_babelfont(document): insert_to_preamble(document, pretext) +def revert_minionpro(document): + " Revert native MinionPro font definition (with extra options) to LaTeX " + + if get_bool_value(document.header, "\\use_non_tex_fonts"): + return + + regexp = re.compile(r'(\\font_roman_opts)') + x = find_re(document.header, regexp, 0) + if x == -1: + return + + # We need to use this regex since split() does not handle quote protection + romanopts = re.findall(r'[^"\s]\S*|".+?"', document.header[x]) + opts = romanopts[1].strip('"') + + i = find_token(document.header, "\\font_roman", 0) + if i == -1: + document.warning("Malformed LyX document: Missing \\font_roman.") + return + else: + # We need to use this regex since split() does not handle quote protection + romanfont = re.findall(r'[^"\s]\S*|".+?"', document.header[i]) + roman = romanfont[1].strip('"') + if roman != "minionpro": + return + romanfont[1] = '"default"' + document.header[i] = " ".join(romanfont) + 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 += opts + preamble += "]{MinionPro}" + add_to_preamble(document, [preamble]) + del document.header[x] + + +def revert_font_opts(document): + " revert font options by outputting \\setxxxfont or \\babelfont to the preamble " + + NonTeXFonts = get_bool_value(document.header, "\\use_non_tex_fonts") + Babel = (get_value(document.header, "\\language_package") == "babel") + + # 1. Roman + regexp = re.compile(r'(\\font_roman_opts)') + i = find_re(document.header, regexp, 0) + if i != -1: + # We need to use this regex since split() does not handle quote protection + romanopts = re.findall(r'[^"\s]\S*|".+?"', document.header[i]) + opts = romanopts[1].strip('"') + del document.header[i] + if NonTeXFonts: + regexp = re.compile(r'(\\font_roman)') + i = find_re(document.header, regexp, 0) + if i != -1: + # We need to use this regex since split() does not handle quote protection + romanfont = re.findall(r'[^"\s]\S*|".+?"', document.header[i]) + font = romanfont[2].strip('"') + romanfont[2] = '"default"' + document.header[i] = " ".join(romanfont) + if font != "default": + if Babel: + preamble = "\\babelfont{rm}[" + else: + preamble = "\\setmainfont[" + preamble += opts + preamble += "," + preamble += "Mapping=tex-text]{" + preamble += font + preamble += "}" + add_to_preamble(document, [preamble]) + + # 2. Sans + regexp = re.compile(r'(\\font_sans_opts)') + i = find_re(document.header, regexp, 0) + if i != -1: + scaleval = 100 + # We need to use this regex since split() does not handle quote protection + sfopts = re.findall(r'[^"\s]\S*|".+?"', document.header[i]) + opts = sfopts[1].strip('"') + del document.header[i] + if NonTeXFonts: + regexp = re.compile(r'(\\font_sf_scale)') + i = find_re(document.header, regexp, 0) + if i != -1: + scaleval = get_value(document.header, "\\font_sf_scale" , i).split()[1] + regexp = re.compile(r'(\\font_sans)') + i = find_re(document.header, regexp, 0) + if i != -1: + # We need to use this regex since split() does not handle quote protection + sffont = re.findall(r'[^"\s]\S*|".+?"', document.header[i]) + font = sffont[2].strip('"') + sffont[2] = '"default"' + document.header[i] = " ".join(sffont) + if font != "default": + if Babel: + preamble = "\\babelfont{sf}[" + else: + preamble = "\\setsansfont[" + preamble += opts + preamble += "," + if scaleval != 100: + preamble += "Scale=0." + preamble += scaleval + preamble += "," + preamble += "Mapping=tex-text]{" + preamble += font + preamble += "}" + add_to_preamble(document, [preamble]) + + # 3. Typewriter + regexp = re.compile(r'(\\font_typewriter_opts)') + i = find_re(document.header, regexp, 0) + if i != -1: + scaleval = 100 + # We need to use this regex since split() does not handle quote protection + ttopts = re.findall(r'[^"\s]\S*|".+?"', document.header[i]) + opts = ttopts[1].strip('"') + del document.header[i] + if NonTeXFonts: + regexp = re.compile(r'(\\font_tt_scale)') + i = find_re(document.header, regexp, 0) + if i != -1: + scaleval = get_value(document.header, "\\font_tt_scale" , i).split()[1] + regexp = re.compile(r'(\\font_typewriter)') + i = find_re(document.header, regexp, 0) + if i != -1: + # We need to use this regex since split() does not handle quote protection + ttfont = re.findall(r'[^"\s]\S*|".+?"', document.header[i]) + font = ttfont[2].strip('"') + ttfont[2] = '"default"' + document.header[i] = " ".join(ttfont) + if font != "default": + if Babel: + preamble = "\\babelfont{tt}[" + else: + preamble = "\\setmonofont[" + preamble += opts + preamble += "," + if scaleval != 100: + preamble += "Scale=0." + preamble += scaleval + preamble += "," + preamble += "Mapping=tex-text]{" + preamble += font + preamble += "}" + add_to_preamble(document, [preamble]) + + +def revert_plainNotoFonts_xopts(document): + " Revert native (straight) Noto font definition (with extra options) to LaTeX " + + if get_bool_value(document.header, "\\use_non_tex_fonts"): + return + + osf = False + y = find_token(document.header, "\\font_osf true", 0) + if y != -1: + osf = True + + regexp = re.compile(r'(\\font_roman_opts)') + x = find_re(document.header, regexp, 0) + if x == -1 and not osf: + return + + opts = "" + if x != -1: + # We need to use this regex since split() does not handle quote protection + romanopts = re.findall(r'[^"\s]\S*|".+?"', document.header[x]) + opts = romanopts[1].strip('"') + if osf: + if opts != "": + opts += ", " + opts += "osf" + + i = find_token(document.header, "\\font_roman", 0) + if i == -1: + return + + # We need to use this regex since split() does not handle quote protection + romanfont = re.findall(r'[^"\s]\S*|".+?"', document.header[i]) + roman = romanfont[1].strip('"') + if roman != "NotoSerif-TLF": + return + + j = find_token(document.header, "\\font_sans", 0) + if j == -1: + return + + # We need to use this regex since split() does not handle quote protection + sffont = re.findall(r'[^"\s]\S*|".+?"', document.header[j]) + sf = sffont[1].strip('"') + if sf != "default": + return + + j = find_token(document.header, "\\font_typewriter", 0) + if j == -1: + return + + # We need to use this regex since split() does not handle quote protection + ttfont = re.findall(r'[^"\s]\S*|".+?"', document.header[j]) + tt = ttfont[1].strip('"') + if tt != "default": + return + + # So we have noto as "complete font" + romanfont[1] = '"default"' + document.header[i] = " ".join(romanfont) + + preamble = "\\usepackage[" + preamble += opts + preamble += "]{noto}" + add_to_preamble(document, [preamble]) + if osf: + document.header[y] = "\\font_osf false" + if x != -1: + del document.header[x] + + +def revert_notoFonts_xopts(document): + " Revert native (extended) Noto font definition (with extra options) to LaTeX " + + if get_bool_value(document.header, "\\use_non_tex_fonts"): + return + + fontmap = dict() + fm = createFontMapping(['Noto']) + if revert_fonts(document, fm, fontmap, True): + add_preamble_fonts(document, fontmap) + + +def revert_IBMFonts_xopts(document): + " Revert native IBM font definition (with extra options) to LaTeX " + + if get_bool_value(document.header, "\\use_non_tex_fonts"): + return + + fontmap = dict() + fm = createFontMapping(['IBM']) + ft = "" + if revert_fonts(document, fm, fontmap, True): + add_preamble_fonts(document, fontmap) + + +def revert_AdobeFonts_xopts(document): + " Revert native Adobe font definition (with extra options) to LaTeX " + + if get_bool_value(document.header, "\\use_non_tex_fonts"): + return + + fontmap = dict() + fm = createFontMapping(['Adobe']) + ft = "" + if revert_fonts(document, fm, fontmap, True): + add_preamble_fonts(document, fontmap) + + +def convert_osf(document): + " Convert \\font_osf param to new format " + + NonTeXFonts = get_bool_value(document.header, "\\use_non_tex_fonts") + + i = find_token(document.header, '\\font_osf', 0) + if i == -1: + document.warning("Malformed LyX document: Missing \\font_osf.") + return + + osfsf = ["biolinum", "ADOBESourceSansPro", "NotoSansRegular", "NotoSansMedium", "NotoSansThin", "NotoSansLight", "NotoSansExtralight" ] + osftt = ["ADOBESourceCodePro", "NotoMonoRegular" ] + + osfval = str2bool(get_value(document.header, "\\font_osf", i)) + document.header[i] = document.header[i].replace("\\font_osf", "\\font_roman_osf") + + if NonTeXFonts: + document.header.insert(i, "\\font_sans_osf false") + document.header.insert(i + 1, "\\font_typewriter_osf false") + return + + if osfval: + x = find_token(document.header, "\\font_sans", 0) + if x == -1: + document.warning("Malformed LyX document: Missing \\font_sans.") + else: + # We need to use this regex since split() does not handle quote protection + sffont = re.findall(r'[^"\s]\S*|".+?"', document.header[x]) + sf = sffont[1].strip('"') + if sf in osfsf: + document.header.insert(i, "\\font_sans_osf true") + else: + document.header.insert(i, "\\font_sans_osf false") + + x = find_token(document.header, "\\font_typewriter", 0) + if x == -1: + document.warning("Malformed LyX document: Missing \\font_typewriter.") + else: + # We need to use this regex since split() does not handle quote protection + ttfont = re.findall(r'[^"\s]\S*|".+?"', document.header[x]) + tt = ttfont[1].strip('"') + if tt in osftt: + document.header.insert(i + 1, "\\font_typewriter_osf true") + else: + document.header.insert(i + 1, "\\font_typewriter_osf false") + + else: + document.header.insert(i, "\\font_sans_osf false") + document.header.insert(i + 1, "\\font_typewriter_osf false") + + +def revert_osf(document): + " Revert \\font_*_osf params " + + NonTeXFonts = get_bool_value(document.header, "\\use_non_tex_fonts") + + i = find_token(document.header, '\\font_roman_osf', 0) + if i == -1: + document.warning("Malformed LyX document: Missing \\font_roman_osf.") + return + + osfval = str2bool(get_value(document.header, "\\font_roman_osf", i)) + document.header[i] = document.header[i].replace("\\font_roman_osf", "\\font_osf") + + i = find_token(document.header, '\\font_sans_osf', 0) + if i == -1: + document.warning("Malformed LyX document: Missing \\font_sans_osf.") + return + + osfval = str2bool(get_value(document.header, "\\font_sans_osf", i)) + del document.header[i] + + i = find_token(document.header, '\\font_typewriter_osf', 0) + if i == -1: + document.warning("Malformed LyX document: Missing \\font_typewriter_osf.") + return + + osfval |= str2bool(get_value(document.header, "\\font_typewriter_osf", i)) + del document.header[i] + + if osfval: + i = find_token(document.header, '\\font_osf', 0) + if i == -1: + document.warning("Malformed LyX document: Missing \\font_osf.") + return + document.header[i] = "\\font_osf true" + + +def revert_texfontopts(document): + " Revert native TeX font definitions (with extra options) to LaTeX " + + if get_bool_value(document.header, "\\use_non_tex_fonts"): + return + + rmfonts = ["ccfonts", "cochineal", "utopia", "garamondx", "libertine", "lmodern", "palatino", "times", "xcharter" ] + + # First the sf (biolinum only) + regexp = re.compile(r'(\\font_sans_opts)') + x = find_re(document.header, regexp, 0) + if x != -1: + # We need to use this regex since split() does not handle quote protection + sfopts = re.findall(r'[^"\s]\S*|".+?"', document.header[x]) + opts = sfopts[1].strip('"') + i = find_token(document.header, "\\font_sans", 0) + if i == -1: + document.warning("Malformed LyX document: Missing \\font_sans.") + else: + # We need to use this regex since split() does not handle quote protection + sffont = re.findall(r'[^"\s]\S*|".+?"', document.header[i]) + sans = sffont[1].strip('"') + if sans == "biolinum": + sf_scale = 100.0 + sffont[1] = '"default"' + document.header[i] = " ".join(sffont) + osf = False + j = find_token(document.header, "\\font_sans_osf true", 0) + if j != -1: + osf = True + k = find_token(document.header, "\\font_sf_scale", 0) + if k == -1: + document.warning("Malformed LyX document: Missing \\font_sf_scale.") + else: + sfscale = document.header[k].split() + val = sfscale[1] + sfscale[1] = "100" + document.header[k] = " ".join(sfscale) + try: + # float() can throw + sf_scale = float(val) + except: + document.warning("Invalid font_sf_scale value: " + val) + preamble = "\\usepackage[" + if osf: + document.header[j] = "\\font_sans_osf false" + preamble += "osf," + if sf_scale != 100.0: + preamble += 'scaled=' + str(sf_scale / 100.0) + ',' + preamble += opts + preamble += "]{biolinum}" + add_to_preamble(document, [preamble]) + del document.header[x] + + regexp = re.compile(r'(\\font_roman_opts)') + x = find_re(document.header, regexp, 0) + if x == -1: + return + + # We need to use this regex since split() does not handle quote protection + romanopts = re.findall(r'[^"\s]\S*|".+?"', document.header[x]) + opts = romanopts[1].strip('"') + + i = find_token(document.header, "\\font_roman", 0) + if i == -1: + document.warning("Malformed LyX document: Missing \\font_roman.") + return + else: + # We need to use this regex since split() does not handle quote protection + romanfont = re.findall(r'[^"\s]\S*|".+?"', document.header[i]) + roman = romanfont[1].strip('"') + if not roman in rmfonts: + return + romanfont[1] = '"default"' + document.header[i] = " ".join(romanfont) + package = roman + if roman == "utopia": + package = "fourier" + elif roman == "palatino": + package = "mathpazo" + elif roman == "times": + package = "mathptmx" + elif roman == "xcharter": + package = "XCharter" + osf = "" + j = find_token(document.header, "\\font_roman_osf true", 0) + if j != -1: + if roman == "cochineal": + osf = "proportional,osf," + elif roman == "utopia": + osf = "oldstyle," + elif roman == "garamondx": + osf = "osfI," + elif roman == "libertine": + osf = "osf," + elif roman == "palatino": + osf = "osf," + elif roman == "xcharter": + osf = "osf," + document.header[j] = "\\font_roman_osf false" + k = find_token(document.header, "\\font_sc true", 0) + if k != -1: + if roman == "utopia": + osf += "expert," + if roman == "palatino" and osf == "": + osf = "sc," + document.header[k] = "\\font_sc false" + preamble = "\\usepackage[" + preamble += osf + preamble += opts + preamble += "]{" + package + "}" + add_to_preamble(document, [preamble]) + del document.header[x] + + +def convert_CantarellFont(document): + " Handle Cantarell font definition to LaTeX " + + if not get_bool_value(document.header, "\\use_non_tex_fonts"): + fm = createFontMapping(['Cantarell']) + convert_fonts(document, fm, "oldstyle") + +def revert_CantarellFont(document): + " Revert native Cantarell font definition to LaTeX " + + if not get_bool_value(document.header, "\\use_non_tex_fonts"): + fontmap = dict() + fm = createFontMapping(['Cantarell']) + if revert_fonts(document, fm, fontmap, False, True): + add_preamble_fonts(document, fontmap) + +def convert_ChivoFont(document): + " Handle Chivo font definition to LaTeX " + + if not get_bool_value(document.header, "\\use_non_tex_fonts"): + fm = createFontMapping(['Chivo']) + convert_fonts(document, fm, "oldstyle") + +def revert_ChivoFont(document): + " Revert native Chivo font definition to LaTeX " + + if not get_bool_value(document.header, "\\use_non_tex_fonts"): + fontmap = dict() + fm = createFontMapping(['Chivo']) + if revert_fonts(document, fm, fontmap, False, True): + add_preamble_fonts(document, fontmap) + + +def convert_FiraFont(document): + " Handle Fira font definition to LaTeX " + + if not get_bool_value(document.header, "\\use_non_tex_fonts"): + fm = createFontMapping(['Fira']) + convert_fonts(document, fm, "lf") + +def revert_FiraFont(document): + " Revert native Fira font definition to LaTeX " + + if not get_bool_value(document.header, "\\use_non_tex_fonts"): + fontmap = dict() + fm = createFontMapping(['Fira']) + if revert_fonts(document, fm, fontmap, False, True): + add_preamble_fonts(document, fontmap) + + +def convert_Semibolds(document): + " Move semibold options to extraopts " + + NonTeXFonts = get_bool_value(document.header, "\\use_non_tex_fonts") + + i = find_token(document.header, "\\font_roman", 0) + if i == -1: + document.warning("Malformed LyX document: Missing \\font_roman.") + else: + # We need to use this regex since split() does not handle quote protection + romanfont = re.findall(r'[^"\s]\S*|".+?"', document.header[i]) + roman = romanfont[1].strip('"') + if roman == "IBMPlexSerifSemibold": + romanfont[1] = '"IBMPlexSerif"' + document.header[i] = " ".join(romanfont) + + if NonTeXFonts == False: + regexp = re.compile(r'(\\font_roman_opts)') + x = find_re(document.header, regexp, 0) + if x == -1: + # Sensible place to insert tag + fo = find_token(document.header, "\\font_sf_scale") + if fo == -1: + document.warning("Malformed LyX document! Missing \\font_sf_scale") + else: + document.header.insert(fo, "\\font_roman_opts \"semibold\"") + else: + # We need to use this regex since split() does not handle quote protection + romanopts = re.findall(r'[^"\s]\S*|".+?"', document.header[x]) + document.header[x] = "\\font_roman_opts \"semibold, " + romanopts[1].strip('"') + "\"" + + i = find_token(document.header, "\\font_sans", 0) + if i == -1: + document.warning("Malformed LyX document: Missing \\font_sans.") + else: + # We need to use this regex since split() does not handle quote protection + sffont = re.findall(r'[^"\s]\S*|".+?"', document.header[i]) + sf = sffont[1].strip('"') + if sf == "IBMPlexSansSemibold": + sffont[1] = '"IBMPlexSans"' + document.header[i] = " ".join(sffont) + + if NonTeXFonts == False: + regexp = re.compile(r'(\\font_sans_opts)') + x = find_re(document.header, regexp, 0) + if x == -1: + # Sensible place to insert tag + fo = find_token(document.header, "\\font_sf_scale") + if fo == -1: + document.warning("Malformed LyX document! Missing \\font_sf_scale") + else: + document.header.insert(fo, "\\font_sans_opts \"semibold\"") + else: + # We need to use this regex since split() does not handle quote protection + sfopts = re.findall(r'[^"\s]\S*|".+?"', document.header[x]) + document.header[x] = "\\font_sans_opts \"semibold, " + sfopts[1].strip('"') + "\"" + + i = find_token(document.header, "\\font_typewriter", 0) + if i == -1: + document.warning("Malformed LyX document: Missing \\font_typewriter.") + else: + # We need to use this regex since split() does not handle quote protection + ttfont = re.findall(r'[^"\s]\S*|".+?"', document.header[i]) + tt = ttfont[1].strip('"') + if tt == "IBMPlexMonoSemibold": + ttfont[1] = '"IBMPlexMono"' + document.header[i] = " ".join(ttfont) + + if NonTeXFonts == False: + regexp = re.compile(r'(\\font_typewriter_opts)') + x = find_re(document.header, regexp, 0) + if x == -1: + # Sensible place to insert tag + fo = find_token(document.header, "\\font_tt_scale") + if fo == -1: + document.warning("Malformed LyX document! Missing \\font_tt_scale") + else: + document.header.insert(fo, "\\font_typewriter_opts \"semibold\"") + else: + # We need to use this regex since split() does not handle quote protection + ttopts = re.findall(r'[^"\s]\S*|".+?"', document.header[x]) + document.header[x] = "\\font_typewriter_opts \"semibold, " + sfopts[1].strip('"') + "\"" + + +def convert_NotoRegulars(document): + " Merge diverse noto reagular fonts " + + i = find_token(document.header, "\\font_roman", 0) + if i == -1: + document.warning("Malformed LyX document: Missing \\font_roman.") + else: + # We need to use this regex since split() does not handle quote protection + romanfont = re.findall(r'[^"\s]\S*|".+?"', document.header[i]) + roman = romanfont[1].strip('"') + if roman == "NotoSerif-TLF": + romanfont[1] = '"NotoSerifRegular"' + document.header[i] = " ".join(romanfont) + + i = find_token(document.header, "\\font_sans", 0) + if i == -1: + document.warning("Malformed LyX document: Missing \\font_sans.") + else: + # We need to use this regex since split() does not handle quote protection + sffont = re.findall(r'[^"\s]\S*|".+?"', document.header[i]) + sf = sffont[1].strip('"') + if sf == "NotoSans-TLF": + sffont[1] = '"NotoSansRegular"' + document.header[i] = " ".join(sffont) + + i = find_token(document.header, "\\font_typewriter", 0) + if i == -1: + document.warning("Malformed LyX document: Missing \\font_typewriter.") + else: + # We need to use this regex since split() does not handle quote protection + ttfont = re.findall(r'[^"\s]\S*|".+?"', document.header[i]) + tt = ttfont[1].strip('"') + if tt == "NotoMono-TLF": + ttfont[1] = '"NotoMonoRegular"' + document.header[i] = " ".join(ttfont) + + +def convert_CrimsonProFont(document): + " Handle CrimsonPro font definition to LaTeX " + + if not get_bool_value(document.header, "\\use_non_tex_fonts"): + fm = createFontMapping(['CrimsonPro']) + convert_fonts(document, fm, "lf") + +def revert_CrimsonProFont(document): + " Revert native CrimsonPro font definition to LaTeX " + + if not get_bool_value(document.header, "\\use_non_tex_fonts"): + fontmap = dict() + fm = createFontMapping(['CrimsonPro']) + if revert_fonts(document, fm, fontmap, False, True): + add_preamble_fonts(document, fontmap) + + +def revert_pagesizes(document): + " Revert new page sizes in memoir and KOMA to options " + + if document.textclass != "memoir" and document.textclass[:2] != "scr": + return + + i = find_token(document.header, "\\use_geometry true", 0) + if i != -1: + return + + defsizes = ["default", "custom", "letterpaper", "legalpaper", "executivepaper", "a4paper", "a5paper", "b5paper"] + + i = find_token(document.header, "\\papersize", 0) + if i == -1: + document.warning("Malformed LyX document! Missing \\papersize header.") + return + val = get_value(document.header, "\\papersize", i) + if val in defsizes: + # nothing to do + return + + document.header[i] = "\\papersize default" + + i = find_token(document.header, "\\options", 0) + if i == -1: + i = find_token(document.header, "\\textclass", 0) + if i == -1: + document.warning("Malformed LyX document! Missing \\textclass header.") + return + document.header.insert(i, "\\options " + val) + return + document.header[i] = document.header[i] + "," + val + + +def convert_pagesizes(document): + " Convert to new page sizes in memoir and KOMA to options " + + if document.textclass != "memoir" and document.textclass[:3] != "scr": + return + + i = find_token(document.header, "\\use_geometry true", 0) + if i != -1: + return + + defsizes = ["default", "custom", "letterpaper", "legalpaper", "executivepaper", "a4paper", "a5paper", "b5paper"] + + i = find_token(document.header, "\\papersize", 0) + if i == -1: + document.warning("Malformed LyX document! Missing \\papersize header.") + return + val = get_value(document.header, "\\papersize", i) + if val in defsizes: + # nothing to do + return + + i = find_token(document.header, "\\use_geometry false", 0) + if i != -1: + # Maintain use of geometry + document.header[1] = "\\use_geometry true" + +def revert_komafontsizes(document): + " Revert new font sizes in KOMA to options " + + if document.textclass[:3] != "scr": + return + + i = find_token(document.header, "\\paperfontsize", 0) + if i == -1: + document.warning("Malformed LyX document! Missing \\paperfontsize header.") + return + + defsizes = ["default", "10", "11", "12"] + + val = get_value(document.header, "\\paperfontsize", i) + if val in defsizes: + # nothing to do + return + + document.header[i] = "\\paperfontsize default" + + fsize = "fontsize=" + val + + i = find_token(document.header, "\\options", 0) + if i == -1: + i = find_token(document.header, "\\textclass", 0) + if i == -1: + document.warning("Malformed LyX document! Missing \\textclass header.") + return + document.header.insert(i, "\\options " + fsize) + return + document.header[i] = document.header[i] + "," + fsize + + +def revert_dupqualicites(document): + " Revert qualified citation list commands with duplicate keys to ERT " + + # LyX 2.3 only supports qualified citation lists with unique keys. Thus, + # we need to revert those with multiple uses of the same key. + + # Get cite engine + engine = "basic" + i = find_token(document.header, "\\cite_engine", 0) + if i == -1: + document.warning("Malformed document! Missing \\cite_engine") + else: + engine = get_value(document.header, "\\cite_engine", i) + + if not engine in ["biblatex", "biblatex-natbib"]: + return + + # Citation insets that support qualified lists, with their LaTeX code + ql_citations = { + "cite" : "cites", + "Cite" : "Cites", + "citet" : "textcites", + "Citet" : "Textcites", + "citep" : "parencites", + "Citep" : "Parencites", + "Footcite" : "Smartcites", + "footcite" : "smartcites", + "Autocite" : "Autocites", + "autocite" : "autocites", + } + + i = 0 + while (True): + i = find_token(document.body, "\\begin_inset CommandInset citation", i) + if i == -1: + break + j = find_end_of_inset(document.body, i) + if j == -1: + document.warning("Can't find end of citation inset at line %d!!" %(i)) + i += 1 + continue + + k = find_token(document.body, "LatexCommand", i, j) + if k == -1: + document.warning("Can't find LatexCommand for citation inset at line %d!" %(i)) + i = j + 1 + continue + + cmd = get_value(document.body, "LatexCommand", k) + if not cmd in list(ql_citations.keys()): + i = j + 1 + continue + + pres = find_token(document.body, "pretextlist", i, j) + posts = find_token(document.body, "posttextlist", i, j) + if pres == -1 and posts == -1: + # nothing to do. + i = j + 1 + continue + + key = get_quoted_value(document.body, "key", i, j) + if not key: + document.warning("Citation inset at line %d does not have a key!" %(i)) + i = j + 1 + continue + + keys = key.split(",") + ukeys = list(set(keys)) + if len(keys) == len(ukeys): + # no duplicates. + i = j + 1 + continue + + pretexts = get_quoted_value(document.body, "pretextlist", pres) + posttexts = get_quoted_value(document.body, "posttextlist", posts) + + pre = get_quoted_value(document.body, "before", i, j) + post = get_quoted_value(document.body, "after", i, j) + prelist = pretexts.split("\t") + premap = dict() + for pp in prelist: + ppp = pp.split(" ", 1) + val = "" + if len(ppp) > 1: + val = ppp[1] + else: + val = "" + if ppp[0] in premap: + premap[ppp[0]] = premap[ppp[0]] + "\t" + val + else: + premap[ppp[0]] = val + postlist = posttexts.split("\t") + postmap = dict() + num = 1 + for pp in postlist: + ppp = pp.split(" ", 1) + val = "" + if len(ppp) > 1: + val = ppp[1] + else: + val = "" + if ppp[0] in postmap: + postmap[ppp[0]] = postmap[ppp[0]] + "\t" + val + else: + postmap[ppp[0]] = val + # Replace known new commands with ERT + if "(" in pre or ")" in pre: + pre = "{" + pre + "}" + if "(" in post or ")" in post: + post = "{" + post + "}" + res = "\\" + ql_citations[cmd] + if pre: + res += "(" + pre + ")" + if post: + res += "(" + post + ")" + elif pre: + res += "()" + for kk in keys: + if premap.get(kk, "") != "": + akeys = premap[kk].split("\t", 1) + akey = akeys[0] + if akey != "": + res += "[" + akey + "]" + if len(akeys) > 1: + premap[kk] = "\t".join(akeys[1:]) + else: + premap[kk] = "" + if postmap.get(kk, "") != "": + akeys = postmap[kk].split("\t", 1) + akey = akeys[0] + if akey != "": + res += "[" + akey + "]" + if len(akeys) > 1: + postmap[kk] = "\t".join(akeys[1:]) + else: + postmap[kk] = "" + elif premap.get(kk, "") != "": + res += "[]" + res += "{" + kk + "}" + document.body[i:j+1] = put_cmd_in_ert([res]) + + +def convert_pagesizenames(document): + " Convert LyX page sizes names " + + i = find_token(document.header, "\\papersize", 0) + if i == -1: + document.warning("Malformed LyX document! Missing \\papersize header.") + return + oldnames = ["letterpaper", "legalpaper", "executivepaper", \ + "a0paper", "a1paper", "a2paper", "a3paper", "a4paper", "a5paper", "a6paper", \ + "b0paper", "b1paper", "b2paper", "b3paper", "b4paper", "b5paper", "b6paper", \ + "c0paper", "c1paper", "c2paper", "c3paper", "c4paper", "c5paper", "c6paper"] + val = get_value(document.header, "\\papersize", i) + if val in oldnames: + newval = val.replace("paper", "") + document.header[i] = "\\papersize " + newval + +def revert_pagesizenames(document): + " Convert LyX page sizes names " + + i = find_token(document.header, "\\papersize", 0) + if i == -1: + document.warning("Malformed LyX document! Missing \\papersize header.") + return + newnames = ["letter", "legal", "executive", \ + "a0", "a1", "a2", "a3", "a4", "a5", "a6", \ + "b0", "b1", "b2", "b3", "b4", "b5", "b6", \ + "c0", "c1", "c2", "c3", "c4", "c5", "c6"] + val = get_value(document.header, "\\papersize", i) + if val in newnames: + newval = val + "paper" + document.header[i] = "\\papersize " + newval + + +def revert_theendnotes(document): + " Reverts native support of \\theendnotes to TeX-code " + + if not "endnotes" in document.get_module_list() and not "foottoend" in document.get_module_list(): + return + + i = 0 + while True: + i = find_token(document.body, "\\begin_inset FloatList endnote", i + 1) + 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 FloatList inset") + continue + + document.body[i : j + 1] = put_cmd_in_ert("\\theendnotes") + + +def revert_enotez(document): + " Reverts native support of enotez package to TeX-code " + + if not "enotez" in document.get_module_list() and not "foottoenotez" in document.get_module_list(): + return + + use = False + if find_token(document.body, "\\begin_inset Flex Endnote", 0) != -1: + use = True + + revert_flex_inset(document.body, "Endnote", "\\endnote") + + i = 0 + while True: + i = find_token(document.body, "\\begin_inset FloatList endnote", i + 1) + if i == -1: + break + j = find_end_of_inset(document.body, i) + if j == -1: + document.warning("Malformed LyX document: Can't find end of FloatList inset") + continue + + use = True + document.body[i : j + 1] = put_cmd_in_ert("\\printendnotes") + + if use: + add_to_preamble(document, ["\\usepackage{enotez}"]) + document.del_module("enotez") + document.del_module("foottoenotez") + + +def revert_memoir_endnotes(document): + " Reverts native support of memoir endnotes to TeX-code " + + if document.textclass != "memoir": + return + + encommand = "\\pagenote" + modules = document.get_module_list() + if "enotez" in modules or "foottoenotez" in modules or "endnotes" in modules or "foottoend" in modules: + encommand = "\\endnote" + + revert_flex_inset(document.body, "Endnote", encommand) + + i = 0 + while True: + i = find_token(document.body, "\\begin_inset FloatList pagenote", i + 1) + if i == -1: + break + j = find_end_of_inset(document.body, i) + if j == -1: + document.warning("Malformed LyX document: Can't find end of FloatList inset") + continue + + if document.body[i] == "\\begin_inset FloatList pagenote*": + document.body[i : j + 1] = put_cmd_in_ert("\\printpagenotes*") + else: + document.body[i : j + 1] = put_cmd_in_ert("\\printpagenotes") + add_to_preamble(document, ["\\makepagenote"]) + + +def revert_totalheight(document): + " Reverts graphics height parameter from totalheight to height " + + relative_heights = { + "\\textwidth" : "text%", + "\\columnwidth" : "col%", + "\\paperwidth" : "page%", + "\\linewidth" : "line%", + "\\textheight" : "theight%", + "\\paperheight" : "pheight%", + "\\baselineskip " : "baselineskip%" + } + i = 0 + while (True): + i = find_token(document.body, "\\begin_inset Graphics", i) + if i == -1: + break + j = find_end_of_inset(document.body, i) + if j == -1: + document.warning("Can't find end of graphics inset at line %d!!" %(i)) + i += 1 + continue + + rx = re.compile(r'\s*special\s*(\S+)$') + rxx = re.compile(r'(\d*\.*\d+)(\S+)$') + k = find_re(document.body, rx, i, j) + special = "" + oldheight = "" + if k != -1: + m = rx.match(document.body[k]) + if m: + special = m.group(1) + mspecial = special.split(',') + for spc in mspecial: + if spc[:7] == "height=": + oldheight = spc.split('=')[1] + ms = rxx.search(oldheight) + if ms: + oldval = ms.group(1) + oldunit = ms.group(2) + if oldval[1] == ".": + oldval = "0" + oldval + if oldunit in list(relative_heights.keys()): + oldval = str(float(oldval) * 100) + oldunit = relative_heights[oldunit] + oldheight = oldval + oldunit + mspecial.remove(spc) + break + if len(mspecial) > 0: + special = ",".join(mspecial) + else: + special = "" + + rx = re.compile(r'(\s*height\s*)(\S+)$') + kk = find_re(document.body, rx, i, j) + if kk != -1: + m = rx.match(document.body[kk]) + val = "" + if m: + val = m.group(2) + if k != -1: + if special != "": + val = val + "," + special + document.body[k] = "\tspecial " + "totalheight=" + val + else: + document.body.insert(kk, "\tspecial totalheight=" + val) + if oldheight != "": + document.body[kk] = m.group(1) + oldheight + else: + del document.body[kk] + elif oldheight != "": + if special != "": + document.body[k] = "\tspecial " + special + document.body.insert(k, "\theight " + oldheight) + else: + document.body[k] = "\theight " + oldheight + i = j + 1 + + +def convert_totalheight(document): + " Converts graphics height parameter from totalheight to height " + + relative_heights = { + "text%" : "\\textwidth", + "col%" : "\\columnwidth", + "page%" : "\\paperwidth", + "line%" : "\\linewidth", + "theight%" : "\\textheight", + "pheight%" : "\\paperheight", + "baselineskip%" : "\\baselineskip" + } + i = 0 + while (True): + i = find_token(document.body, "\\begin_inset Graphics", i) + if i == -1: + break + j = find_end_of_inset(document.body, i) + if j == -1: + document.warning("Can't find end of graphics inset at line %d!!" %(i)) + i += 1 + continue + + rx = re.compile(r'\s*special\s*(\S+)$') + k = find_re(document.body, rx, i, j) + special = "" + newheight = "" + if k != -1: + m = rx.match(document.body[k]) + if m: + special = m.group(1) + mspecial = special.split(',') + for spc in mspecial: + if spc[:12] == "totalheight=": + newheight = spc.split('=')[1] + mspecial.remove(spc) + break + if len(mspecial) > 0: + special = ",".join(mspecial) + else: + special = "" + + rx = re.compile(r'(\s*height\s*)(\d+)(\S+)$') + kk = find_re(document.body, rx, i, j) + if kk != -1: + m = rx.match(document.body[kk]) + val = "" + if m: + val = m.group(2) + unit = m.group(3) + if unit in list(relative_heights.keys()): + val = str(float(val) / 100) + unit = relative_heights[unit] + if k != -1: + if special != "": + val = val + unit + "," + special + document.body[k] = "\tspecial " + "height=" + val + else: + document.body.insert(kk + 1, "\tspecial height=" + val + unit) + if newheight != "": + document.body[kk] = m.group(1) + newheight + else: + del document.body[kk] + elif newheight != "": + document.body.insert(k, "\theight " + newheight) + i = j + 1 + + +def convert_changebars(document): + " Converts the changebars module to native solution " + + if not "changebars" in document.get_module_list(): + return + + i = find_token(document.header, "\\output_changes", 0) + if i == -1: + document.warning("Malformed LyX document! Missing \\output_changes header.") + document.del_module("changebars") + return + + document.header.insert(i, "\\change_bars true") + document.del_module("changebars") + + +def revert_changebars(document): + " Converts native changebar param to module " + + i = find_token(document.header, "\\change_bars", 0) + if i == -1: + document.warning("Malformed LyX document! Missing \\change_bars header.") + return + + val = get_value(document.header, "\\change_bars", i) + + if val == "true": + document.add_module("changebars") + + del document.header[i] + + +def convert_postpone_fragile(document): + " Adds false \\postpone_fragile_content buffer param " + + i = find_token(document.header, "\\output_changes", 0) + if i == -1: + document.warning("Malformed LyX document! Missing \\output_changes header.") + return + # Set this to false for old documents (see #2154) + document.header.insert(i, "\\postpone_fragile_content false") + + +def revert_postpone_fragile(document): + " Remove \\postpone_fragile_content buffer param " + + i = find_token(document.header, "\\postpone_fragile_content", 0) + if i == -1: + document.warning("Malformed LyX document! Missing \\postpone_fragile_content.") + return + + del document.header[i] + + +def revert_colrow_tracking(document): + " Remove change tag from tabular columns/rows " + i = 0 + while True: + i = find_token(document.body, "\\begin_inset Tabular", i+1) + if i == -1: + return + j = find_end_of_inset(document.body, i+1) + if j == -1: + document.warning("Malformed LyX document: Could not find end of tabular.") + continue + for k in range(i, j): + m = re.search('^$', document.body[k]) + if m: + document.body[k] = document.body[k].replace(' change="' + m.group(1) + '"', '') + m = re.search('^$', document.body[k]) + if m: + document.body[k] = document.body[k].replace(' change="' + m.group(1) + '"', '') + + +def convert_counter_maintenance(document): + " Convert \\maintain_unincluded_children buffer param from boolean value tro tristate " + + i = find_token(document.header, "\\maintain_unincluded_children", 0) + if i == -1: + document.warning("Malformed LyX document! Missing \\maintain_unincluded_children.") + return + + val = get_value(document.header, "\\maintain_unincluded_children", i) + + if val == "true": + document.header[i] = "\\maintain_unincluded_children strict" + else: + document.header[i] = "\\maintain_unincluded_children no" + + +def revert_counter_maintenance(document): + " Revert \\maintain_unincluded_children buffer param to previous boolean value " + + i = find_token(document.header, "\\maintain_unincluded_children", 0) + if i == -1: + document.warning("Malformed LyX document! Missing \\maintain_unincluded_children.") + return + + val = get_value(document.header, "\\maintain_unincluded_children", i) + + if val == "no": + document.header[i] = "\\maintain_unincluded_children false" + else: + document.header[i] = "\\maintain_unincluded_children true" + + +def revert_counter_inset(document): + " Revert counter inset to ERT, where possible" + i = 0 + needed_counters = {} + while True: + i = find_token(document.body, "\\begin_inset CommandInset counter", i) + if i == -1: + break + j = find_end_of_inset(document.body, i) + if j == -1: + document.warning("Can't find end of counter inset at line %d!" % i) + i += 1 + continue + lyx = get_quoted_value(document.body, "lyxonly", i, j) + if lyx == "true": + # there is nothing we can do to affect the LyX counters + document.body[i : j + 1] = [] + i = j + 1 + continue + cnt = get_quoted_value(document.body, "counter", i, j) + if not cnt: + document.warning("No counter given for inset at line %d!" % i) + i = j + 1 + continue + + cmd = get_quoted_value(document.body, "LatexCommand", i, j) + document.warning(cmd) + ert = "" + if cmd == "set": + val = get_quoted_value(document.body, "value", i, j) + if not val: + document.warning("Can't convert counter inset at line %d!" % i) + else: + ert = put_cmd_in_ert("\\setcounter{%s}{%s}" % (cnt, val)) + elif cmd == "addto": + val = get_quoted_value(document.body, "value", i, j) + if not val: + document.warning("Can't convert counter inset at line %d!" % i) + else: + ert = put_cmd_in_ert("\\addtocounter{%s}{%s}" % (cnt, val)) + elif cmd == "reset": + ert = put_cmd_in_ert("\\setcounter{%s}{0}" % (cnt)) + elif cmd == "save": + needed_counters[cnt] = 1 + savecnt = "LyXSave" + cnt + ert = put_cmd_in_ert("\\setcounter{%s}{\\value{%s}}" % (savecnt, cnt)) + elif cmd == "restore": + needed_counters[cnt] = 1 + savecnt = "LyXSave" + cnt + ert = put_cmd_in_ert("\\setcounter{%s}{\\value{%s}}" % (cnt, savecnt)) + else: + document.warning("Unknown counter command `%s' in inset at line %d!" % (cnt, i)) + + if ert: + document.body[i : j + 1] = ert + i += 1 + continue + + pretext = [] + for cnt in needed_counters: + pretext.append("\\newcounter{LyXSave%s}" % (cnt)) + if pretext: + add_to_preamble(document, pretext) + + +def revert_ams_spaces(document): + "Revert InsetSpace medspace and thickspace into their TeX-code counterparts" + Found = False + insets = ["\\medspace{}", "\\thickspace{}"] + for inset in insets: + i = 0 + j = 0 + i = find_token(document.body, "\\begin_inset space " + inset, i) + if i == -1: + continue + end = find_end_of_inset(document.body, i) + subst = put_cmd_in_ert(inset) + document.body[i : end + 1] = subst + Found = True + + if Found == True: + # load amsmath in the preamble if not already loaded + i = find_token(document.header, "\\use_package amsmath 2", 0) + if i == -1: + add_to_preamble(document, ["\\@ifundefined{thickspace}{\\usepackage{amsmath}}{}"]) + return + + +def convert_parskip(document): + " Move old parskip settings to preamble " + + i = find_token(document.header, "\\paragraph_separation skip", 0) + if i == -1: + return + + j = find_token(document.header, "\\defskip", 0) + if j == -1: + document.warning("Malformed LyX document! Missing \\defskip.") + return + + val = get_value(document.header, "\\defskip", j) + + skipval = "\\medskipamount" + if val == "smallskip" or val == "medskip" or val == "bigskip": + skipval = "\\" + val + "amount" + else: + skipval = val + + add_to_preamble(document, ["\\setlength{\\parskip}{" + skipval + "}", "\\setlength{\\parindent}{0pt}"]) + + document.header[i] = "\\paragraph_separation indent" + document.header[j] = "\\paragraph_indentation default" + + +def revert_parskip(document): + " Revert new parskip settings to preamble " + + i = find_token(document.header, "\\paragraph_separation skip", 0) + if i == -1: + return + + j = find_token(document.header, "\\defskip", 0) + if j == -1: + document.warning("Malformed LyX document! Missing \\defskip.") + return + + val = get_value(document.header, "\\defskip", j) + + skipval = "" + if val == "smallskip" or val == "medskip" or val == "bigskip": + skipval = "[skip=\\" + val + "amount]" + elif val == "fullline": + skipval = "[skip=\\baselineskip]" + elif val != "halfline": + skipval = "[skip={" + val + "}]" + + add_to_preamble(document, ["\\usepackage" + skipval + "{parskip}"]) + + document.header[i] = "\\paragraph_separation indent" + document.header[j] = "\\paragraph_indentation default" + + +def revert_line_vspaces(document): + " Revert fulline and halfline vspaces to TeX " + insets = { + "fullline*" : "\\vspace*{\\baselineskip}", + "fullline" : "\\vspace{\\baselineskip}", + "halfline*" : "\\vspace*{0.5\\baselineskip}", + "halfline" : "\\vspace{0.5\\baselineskip}", + } + for inset in insets.keys(): + i = 0 + j = 0 + i = find_token(document.body, "\\begin_inset VSpace " + inset, i) + if i == -1: + continue + end = find_end_of_inset(document.body, i) + subst = put_cmd_in_ert(insets[inset]) + document.body[i : end + 1] = subst + +def convert_libertinus_rm_fonts(document): + """Handle Libertinus serif fonts definition to LaTeX""" + + if not get_bool_value(document.header, "\\use_non_tex_fonts"): + fm = createFontMapping(['Libertinus']) + convert_fonts(document, fm) + +def revert_libertinus_rm_fonts(document): + """Revert Libertinus serif font definition to LaTeX""" + + if not get_bool_value(document.header, "\\use_non_tex_fonts"): + fontmap = dict() + fm = createFontMapping(['libertinus']) + if revert_fonts(document, fm, fontmap): + add_preamble_fonts(document, fontmap) + +def revert_libertinus_sftt_fonts(document): + " Revert Libertinus sans and tt font definitions to LaTeX " + + if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: + preamble = "" + # first sf font + i = find_token(document.header, "\\font_sans \"LibertinusSans-LF\"", 0) + if i != -1: + j = find_token(document.header, "\\font_sans_osf true", 0) + if j != -1: + add_to_preamble(document, ["\\renewcommand{\\sfdefault}{LibertinusSans-OsF}"]) + document.header[j] = "\\font_sans_osf false" + else: + add_to_preamble(document, ["\\renewcommand{\\sfdefault}{LibertinusSans-LF}"]) + document.header[i] = document.header[i].replace("LibertinusSans-LF", "default") + sf_scale = 100.0 + sfval = find_token(document.header, "\\font_sf_scale", 0) + if sfval == -1: + document.warning("Malformed LyX document: Missing \\font_sf_scale.") + else: + sfscale = document.header[sfval].split() + val = sfscale[1] + sfscale[1] = "100" + document.header[sfval] = " ".join(sfscale) + try: + # float() can throw + sf_scale = float(val) + except: + document.warning("Invalid font_sf_scale value: " + val) + if sf_scale != "100.0": + add_to_preamble(document, ["\\renewcommand*{\\LibertinusSans@scale}{" + str(sf_scale / 100.0) + "}"]) + # now tt font + i = find_token(document.header, "\\font_typewriter \"LibertinusMono-TLF\"", 0) + if i != -1: + add_to_preamble(document, ["\\renewcommand{\\ttdefault}{LibertinusMono-TLF}"]) + document.header[i] = document.header[i].replace("LibertinusMono-TLF", "default") + tt_scale = 100.0 + ttval = find_token(document.header, "\\font_tt_scale", 0) + if ttval == -1: + document.warning("Malformed LyX document: Missing \\font_tt_scale.") + else: + ttscale = document.header[ttval].split() + val = ttscale[1] + ttscale[1] = "100" + document.header[ttval] = " ".join(ttscale) + try: + # float() can throw + tt_scale = float(val) + except: + document.warning("Invalid font_tt_scale value: " + val) + if tt_scale != "100.0": + add_to_preamble(document, ["\\renewcommand*{\\LibertinusMono@scale}{" + str(tt_scale / 100.0) + "}"]) + + +def revert_docbook_table_output(document): + i = find_token(document.header, '\\docbook_table_output') + if i != -1: + del document.header[i] + ## # Conversion hub @@ -2305,11 +3983,11 @@ convert = [ [558, [removeFrontMatterStyles]], [559, []], [560, []], - [561, [convert_latexFonts]], # Handle dejavu, ibmplex fonts in GUI + [561, [convert_latexFonts]], # Handle dejavu, ibmplex fonts in GUI [562, []], [563, []], [564, []], - [565, [convert_AdobeFonts]], # Handle adobe fonts in GUI + [565, [convert_AdobeFonts]], # Handle adobe fonts in GUI [566, [convert_hebrew_parentheses]], [567, []], [568, []], @@ -2319,18 +3997,56 @@ convert = [ [572, [convert_notoFonts]], # Added options thin, light, extralight for Noto [573, [convert_inputencoding_namechange]], [574, [convert_ruby_module, convert_utf8_japanese]], - [575, [convert_lineno]], + [575, [convert_lineno, convert_aaencoding]], [576, []], [577, [convert_linggloss]], [578, []], - [579, []] + [579, []], + [580, []], + [581, [convert_osf]], + [582, [convert_AdobeFonts,convert_latexFonts,convert_notoFonts,convert_CantarellFont,convert_FiraFont]],# old font re-converterted due to extra options + [583, [convert_ChivoFont,convert_Semibolds,convert_NotoRegulars,convert_CrimsonProFont]], + [584, []], + [585, [convert_pagesizes]], + [586, []], + [587, [convert_pagesizenames]], + [588, []], + [589, [convert_totalheight]], + [590, [convert_changebars]], + [591, [convert_postpone_fragile]], + [592, []], + [593, [convert_counter_maintenance]], + [594, []], + [595, []], + [596, [convert_parskip]], + [597, [convert_libertinus_rm_fonts]], + [598, []] ] -revert = [[578, [revert_babelfont]], +revert = [[597, [revert_docbook_table_output]], + [596, [revert_libertinus_rm_fonts,revert_libertinus_sftt_fonts]], + [595, [revert_parskip,revert_line_vspaces]], + [594, [revert_ams_spaces]], + [593, [revert_counter_inset]], + [592, [revert_counter_maintenance]], + [591, [revert_colrow_tracking]], + [590, [revert_postpone_fragile]], + [589, [revert_changebars]], + [588, [revert_totalheight]], + [587, [revert_memoir_endnotes,revert_enotez,revert_theendnotes]], + [586, [revert_pagesizenames]], + [585, [revert_dupqualicites]], + [584, [revert_pagesizes,revert_komafontsizes]], + [583, [revert_vcsinfo_rev_abbrev]], + [582, [revert_ChivoFont,revert_CrimsonProFont]], + [581, [revert_CantarellFont,revert_FiraFont]], + [580, [revert_texfontopts,revert_osf]], + [579, [revert_minionpro, revert_plainNotoFonts_xopts, revert_notoFonts_xopts, revert_IBMFonts_xopts, revert_AdobeFonts_xopts, revert_font_opts]], # keep revert_font_opts last! + [578, [revert_babelfont]], [577, [revert_drs]], [576, [revert_linggloss, revert_subexarg]], [575, [revert_new_languages]], - [574, [revert_lineno]], + [574, [revert_lineno, revert_aaencoding]], [573, [revert_ruby_module, revert_utf8_japanese]], [572, [revert_inputencoding_namechange]], [571, [revert_notoFonts]], @@ -2344,7 +4060,7 @@ revert = [[578, [revert_babelfont]], [563, [revert_lformatinfo]], [562, [revert_listpargs]], [561, [revert_l7ninfo]], - [560, [revert_latexFonts]], # Handle dejavu, ibmplex fonts in user preamble + [560, [revert_latexFonts]], # Handle dejavu, ibmplex fonts in user preamble [559, [revert_timeinfo, revert_namenoextinfo]], [558, [revert_dateinfo]], [557, [addFrontMatterStyles]], @@ -2356,7 +4072,7 @@ revert = [[578, [revert_babelfont]], [551, [revert_floatpclass, revert_floatalignment]], [550, [revert_nospellcheck]], [549, [revert_fontenc]], - [548, []],# dummy format change + [548, []], # dummy format change [547, [revert_lscape]], [546, [revert_xcharter]], [545, [revert_paratype]],