lib/lyx2lyx/lyx_2_2.py

   1 # -*- coding: utf-8 -*-
   2 # This file is part of lyx2lyx
   3 # Copyright (C) 2015 The LyX team
   4 #
   5 # This program is free software; you can redistribute it and/or
   6 # modify it under the terms of the GNU General Public License
   7 # as published by the Free Software Foundation; either version 2
   8 # of the License, or (at your option) any later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program; if not, write to the Free Software
  17 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18
  19 """ Convert files to the file format generated by lyx 2.2"""
  20
  21 import re, string
  22 import unicodedata
  23 import sys, os
  24
  25 # Uncomment only what you need to import, please.
  26
  27 #from parser_tools import find_token, find_end_of, find_tokens, \
  28 #  find_token_exact, find_end_of_inset, find_end_of_layout, \
  29 #  find_token_backwards, is_in_inset, get_value, get_quoted_value, \
  30 #  del_token, check_token, get_option_value
  31
  32 from lyx2lyx_tools import (add_to_preamble, put_cmd_in_ert, get_ert,
  33     lyx2latex, lyx2verbatim, length_in_bp, convert_info_insets)
  34 #   insert_to_preamble, latex_length, revert_flex_inset,
  35 #   revert_font_attrs, hex2ratio, str2bool
  36
  37 from parser_tools import (check_token, del_complete_lines,
  38     find_end_of_inset, find_end_of_layout, find_nonempty_line, find_re,
  39     find_substring, find_token, find_token_backwards, get_containing_layout,
  40     get_containing_inset, get_quoted_value, get_value, is_in_inset,
  41     get_bool_value, set_bool_value)
  42
  43
  44 ####################################################################
  45 # Private helper functions
  46
  47 def revert_Argument_to_TeX_brace(document, line, endline, n, nmax, environment, opt, nolastopt):
  48     """
  49     Reverts an InsetArgument to TeX-code
  50     usage:
  51     revert_Argument_to_TeX_brace(document, LineOfBegin, LineOfEnd, StartArgument, EndArgument, isEnvironment, isOpt, notLastOpt)
  52     LineOfBegin is the line  of the \begin_layout or \begin_inset statement
  53     LineOfEnd is the line  of the \end_layout or \end_inset statement, if "0" is given, the end of the file is used instead
  54     StartArgument is the number of the first argument that needs to be converted
  55     EndArgument is the number of the last argument that needs to be converted or the last defined one
  56     isEnvironment must be true, if the layout is for a LaTeX environment
  57     isOpt must be true, if the argument is an optional one
  58     notLastOpt must be true if the argument is mandatory and followed by optional ones
  59     """
  60     lineArg = 0
  61     wasOpt = False
  62     while lineArg != -1 and n < nmax + 1:
  63       lineArg = find_token(document.body, "\\begin_inset Argument " + str(n), line)
  64       if lineArg > endline and endline != 0:
  65         return wasOpt
  66       if lineArg != -1:
  67         beginPlain = find_token(document.body, "\\begin_layout Plain Layout", lineArg)
  68         # we have to assure that no other inset is in the Argument
  69         beginInset = find_token(document.body, "\\begin_inset", beginPlain)
  70         endInset = find_token(document.body, "\\end_inset", beginPlain)
  71         k = beginPlain + 1
  72         l = k
  73         while beginInset < endInset and beginInset != -1:
  74           beginInset = find_token(document.body, "\\begin_inset", k)
  75           endInset = find_token(document.body, "\\end_inset", l)
  76           k = beginInset + 1
  77           l = endInset + 1
  78         if environment == False:
  79           if opt == False:
  80             if nolastopt == False:
  81               document.body[endInset - 2 : endInset + 1] = put_cmd_in_ert("}{")
  82             else:
  83               document.body[endInset - 2 : endInset + 1] = put_cmd_in_ert("}")
  84             del(document.body[lineArg : beginPlain + 1])
  85             wasOpt = False
  86           else:
  87             document.body[endInset - 2 : endInset + 1] = put_cmd_in_ert("]")
  88             document.body[lineArg : beginPlain + 1] = put_cmd_in_ert("[")
  89             wasOpt = True
  90         else:
  91           if opt == False:
  92             document.body[endInset - 2 : endInset + 1] = put_cmd_in_ert("}")
  93             document.body[lineArg : beginPlain + 1] = put_cmd_in_ert("{")
  94             wasOpt = False
  95           else:
  96             document.body[endInset - 2 : endInset + 1] = put_cmd_in_ert("]")
  97             document.body[lineArg : beginPlain + 1] = put_cmd_in_ert("[")
  98             wasOpt = True
  99         n += 1
 100     return wasOpt
 101
 102
 103 ###############################################################################
 104 ###
 105 ### Conversion and reversion routines
 106 ###
 107 ###############################################################################
 108
 109 def convert_longtable_label_internal(document, forward):
 110     """
 111     Convert reference to "LongTableNoNumber" into "Unnumbered" if forward is True
 112     else revert it.
 113     """
 114     old_reference = "\\begin_inset Caption LongTableNoNumber"
 115     new_reference = "\\begin_inset Caption Unnumbered"
 116
 117     # if the purpose is to revert swap the strings roles
 118     if not forward:
 119         old_reference, new_reference = new_reference, old_reference
 120
 121     i = 0
 122     while True:
 123         i = find_token(document.body, old_reference, i)
 124
 125         if i == -1:
 126             return
 127
 128         document.body[i] = new_reference
 129
 130
 131 def convert_longtable_label(document):
 132     convert_longtable_label_internal(document, True)
 133
 134
 135 def revert_longtable_label(document):
 136     convert_longtable_label_internal(document, False)
 137
 138
 139 def convert_separator(document):
 140     """
 141     Convert layout separators to separator insets and add (LaTeX) paragraph
 142     breaks in order to mimic previous LaTeX export.
 143     """
 144
 145     parins = ["\\begin_inset Separator parbreak", "\\end_inset", ""]
 146     parlay = ["\\begin_layout Standard", "\\begin_inset Separator parbreak",
 147               "\\end_inset", "", "\\end_layout", ""]
 148     sty_dict = {
 149         "family" : "default",
 150         "series" : "default",
 151         "shape"  : "default",
 152         "size"   : "default",
 153         "bar"    : "default",
 154         "color"  : "inherit"
 155         }
 156
 157     i = 0
 158     while True:
 159         i = find_token(document.body, "\\begin_deeper", i)
 160         if i == -1:
 161             break
 162
 163         j = find_token_backwards(document.body, "\\end_layout", i-1)
 164         if j != -1:
 165             # reset any text style before inserting the inset
 166             lay = get_containing_layout(document.body, j-1)
 167             if lay != False:
 168                 content = "\n".join(document.body[lay[1]:lay[2]])
 169                 for val in list(sty_dict.keys()):
 170                     if content.find("\\%s" % val) != -1:
 171                         document.body[j:j] = ["\\%s %s" % (val, sty_dict[val])]
 172                         i = i + 1
 173                         j = j + 1
 174             document.body[j:j] = parins
 175             i = i + len(parins) + 1
 176         else:
 177             i = i + 1
 178
 179     i = 0
 180     while True:
 181         i = find_token(document.body, "\\align", i)
 182         if i == -1:
 183             break
 184
 185         lay = get_containing_layout(document.body, i)
 186         if lay != False and lay[0] == "Plain Layout":
 187             i = i + 1
 188             continue
 189
 190         j = find_token_backwards(document.body, "\\end_layout", i-1)
 191         if j != -1:
 192             lay = get_containing_layout(document.body, j-1)
 193             if lay != False and lay[0] == "Standard" \
 194                and find_token(document.body, "\\align", lay[1], lay[2]) == -1 \
 195                and find_token(document.body, "\\begin_inset VSpace", lay[1], lay[2]) == -1:
 196                 # reset any text style before inserting the inset
 197                 content = "\n".join(document.body[lay[1]:lay[2]])
 198                 for val in list(sty_dict.keys()):
 199                     if content.find("\\%s" % val) != -1:
 200                         document.body[j:j] = ["\\%s %s" % (val, sty_dict[val])]
 201                         i = i + 1
 202                         j = j + 1
 203                 document.body[j:j] = parins
 204                 i = i + len(parins) + 1
 205             else:
 206                 i = i + 1
 207         else:
 208             i = i + 1
 209
 210     regexp = re.compile(r'^\\begin_layout (?:(-*)|(\s*))(Separator|EndOfSlide)(?:(-*)|(\s*))$', re.IGNORECASE)
 211
 212     i = 0
 213     while True:
 214         i = find_re(document.body, regexp, i)
 215         if i == -1:
 216             return
 217
 218         j = find_end_of_layout(document.body, i)
 219         if j == -1:
 220             document.warning("Malformed LyX document: Missing `\\end_layout'.")
 221             return
 222
 223         lay = get_containing_layout(document.body, j-1)
 224         if lay != False:
 225             lines = document.body[lay[3]:lay[2]]
 226         else:
 227             lines = []
 228
 229         document.body[i:j+1] = parlay
 230         if len(lines) > 0:
 231             document.body[i+1:i+1] = lines
 232
 233         i = i + len(parlay) + len(lines) + 1
 234
 235
 236 def revert_separator(document):
 237     " Revert separator insets to layout separators "
 238
 239     beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
 240     if document.textclass in beamer_classes:
 241         beglaysep = "\\begin_layout Separator"
 242     else:
 243         beglaysep = "\\begin_layout --Separator--"
 244
 245     parsep = [beglaysep, "", "\\end_layout", ""]
 246     comert = ["\\begin_inset ERT", "status collapsed", "",
 247               "\\begin_layout Plain Layout", "%", "\\end_layout",
 248               "", "\\end_inset", ""]
 249     empert = ["\\begin_inset ERT", "status collapsed", "",
 250               "\\begin_layout Plain Layout", " ", "\\end_layout",
 251               "", "\\end_inset", ""]
 252
 253     i = 0
 254     while True:
 255         i = find_token(document.body, "\\begin_inset Separator", i)
 256         if i == -1:
 257             return
 258
 259         lay = get_containing_layout(document.body, i)
 260         if lay == False:
 261             document.warning("Malformed LyX document: Can't convert separator inset at line " + str(i))
 262             i = i + 1
 263             continue
 264
 265         layoutname = lay[0]
 266         beg = lay[1]
 267         end = lay[2]
 268         kind = get_value(document.body, "\\begin_inset Separator", i, i+1, "plain").split()[1]
 269         before = document.body[beg+1:i]
 270         something_before = len(before) > 0 and len("".join(before)) > 0
 271         j = find_end_of_inset(document.body, i)
 272         after = document.body[j+1:end]
 273         something_after = len(after) > 0 and len("".join(after)) > 0
 274         if kind == "plain":
 275             beg = beg + len(before) + 1
 276         elif something_before:
 277             document.body[i:i] = ["\\end_layout", ""]
 278             i = i + 2
 279             j = j + 2
 280             beg = i
 281             end = end + 2
 282
 283         if kind == "plain":
 284             if something_after:
 285                 document.body[beg:j+1] = empert
 286                 i = i + len(empert)
 287             else:
 288                 document.body[beg:j+1] = comert
 289                 i = i + len(comert)
 290         else:
 291             if something_after:
 292                 if layoutname == "Standard":
 293                     if not something_before:
 294                         document.body[beg:j+1] = parsep
 295                         i = i + len(parsep)
 296                         document.body[i:i] = ["", "\\begin_layout Standard"]
 297                         i = i + 2
 298                     else:
 299                         document.body[beg:j+1] = ["\\begin_layout Standard"]
 300                         i = i + 1
 301                 else:
 302                     document.body[beg:j+1] = ["\\begin_deeper"]
 303                     i = i + 1
 304                     end = end + 1 - (j + 1 - beg)
 305                     if not something_before:
 306                         document.body[i:i] = parsep
 307                         i = i + len(parsep)
 308                         end = end + len(parsep)
 309                     document.body[i:i] = ["\\begin_layout Standard"]
 310                     document.body[end+2:end+2] = ["", "\\end_deeper", ""]
 311                     i = i + 4
 312             else:
 313                 next_par_is_aligned = False
 314                 k = find_nonempty_line(document.body, end+1)
 315                 if k != -1 and check_token(document.body[k], "\\begin_layout"):
 316                     lay = get_containing_layout(document.body, k)
 317                     next_par_is_aligned = lay != False and \
 318                             find_token(document.body, "\\align", lay[1], lay[2]) != -1
 319                 if k != -1 and not next_par_is_aligned \
 320                         and not check_token(document.body[k], "\\end_deeper") \
 321                         and not check_token(document.body[k], "\\begin_deeper"):
 322                     if layoutname == "Standard":
 323                         document.body[beg:j+1] = [beglaysep]
 324                         i = i + 1
 325                     else:
 326                         document.body[beg:j+1] = ["\\begin_deeper", beglaysep]
 327                         end = end + 2 - (j + 1 - beg)
 328                         document.body[end+1:end+1] = ["", "\\end_deeper", ""]
 329                         i = i + 3
 330                 else:
 331                     if something_before:
 332                         del document.body[i:end+1]
 333                     else:
 334                         del document.body[i:end-1]
 335
 336         i = i + 1
 337
 338
 339 def convert_parbreak(document):
 340     """
 341     Convert parbreak separators not specifically used to separate
 342     environments to latexpar separators.
 343     """
 344     parbreakinset = "\\begin_inset Separator parbreak"
 345     i = 0
 346     while True:
 347         i = find_token(document.body, parbreakinset, i)
 348         if i == -1:
 349             return
 350         lay = get_containing_layout(document.body, i)
 351         if lay == False:
 352             document.warning("Malformed LyX document: Can't convert separator inset at line " + str(i))
 353             i += 1
 354             continue
 355         if lay[0] == "Standard":
 356             # Convert only if not alone in the paragraph
 357             k1 = find_nonempty_line(document.body, lay[1] + 1, i + 1)
 358             k2 = find_nonempty_line(document.body, i + 1, lay[2])
 359             if (k1 < i) or (k2 > i + 1) or not check_token(document.body[i], parbreakinset):
 360                 document.body[i] = document.body[i].replace("parbreak", "latexpar")
 361         else:
 362             document.body[i] = document.body[i].replace("parbreak", "latexpar")
 363         i += 1
 364
 365
 366 def revert_parbreak(document):
 367     """
 368     Revert latexpar separators to parbreak separators.
 369     """
 370     i = 0
 371     while True:
 372         i = find_token(document.body, "\\begin_inset Separator latexpar", i)
 373         if i == -1:
 374             return
 375         document.body[i] = document.body[i].replace("latexpar", "parbreak")
 376         i += 1
 377
 378
 379 def revert_smash(document):
 380     " Set amsmath to on if smash commands are used "
 381
 382     commands = ["smash[t]", "smash[b]", "notag"]
 383     i = find_token(document.header, "\\use_package amsmath", 0)
 384     if i == -1:
 385         document.warning("Malformed LyX document: Can't find \\use_package amsmath.")
 386         return
 387     value = get_value(document.header, "\\use_package amsmath", i).split()[1]
 388     if value != "1":
 389         # nothing to do if package is not auto but on or off
 390         return
 391     j = 0
 392     while True:
 393         j = find_token(document.body, '\\begin_inset Formula', j)
 394         if j == -1:
 395             return
 396         k = find_end_of_inset(document.body, j)
 397         if k == -1:
 398             document.warning("Malformed LyX document: Can't find end of Formula inset at line " + str(j))
 399             j += 1
 400             continue
 401         code = "\n".join(document.body[j:k])
 402         for c in commands:
 403             if code.find("\\%s" % c) != -1:
 404                 # set amsmath to on, since it is loaded by the newer format
 405                 document.header[i] = "\\use_package amsmath 2"
 406                 return
 407         j = k
 408
 409
 410 def revert_swissgerman(document):
 411     " Set language german-ch-old to german "
 412     i = 0
 413     if document.language == "german-ch-old":
 414         document.language = "german"
 415         i = find_token(document.header, "\\language", 0)
 416         if i != -1:
 417             document.header[i] = "\\language german"
 418     j = 0
 419     while True:
 420         j = find_token(document.body, "\\lang german-ch-old", j)
 421         if j == -1:
 422             return
 423         document.body[j] = document.body[j].replace("\\lang german-ch-old", "\\lang german")
 424         j = j + 1
 425
 426
 427 def revert_use_package(document, pkg, commands, oldauto, supported):
 428     # oldauto defines how the version we are reverting to behaves:
 429     # if it is true, the old version uses the package automatically.
 430     # if it is false, the old version never uses the package.
 431     # If "supported" is true, the target version also supports this
 432     # package natively.
 433     regexp = re.compile(r'(\\use_package\s+%s)' % pkg)
 434     p = find_re(document.header, regexp, 0)
 435     value = "1" # default is auto
 436     if p != -1:
 437         value = get_value(document.header, "\\use_package" , p).split()[1]
 438         if not supported:
 439             del document.header[p]
 440     if value == "2" and not supported: # on
 441         add_to_preamble(document, ["\\usepackage{" + pkg + "}"])
 442     elif value == "1" and not oldauto: # auto
 443         i = 0
 444         while True:
 445             i = find_token(document.body, '\\begin_inset Formula', i)
 446             if i == -1:
 447                 return
 448             j = find_end_of_inset(document.body, i)
 449             if j == -1:
 450                 document.warning("Malformed LyX document: Can't find end of Formula inset at line " + str(i))
 451                 i += 1
 452                 continue
 453             code = "\n".join(document.body[i:j])
 454             for c in commands:
 455                 if code.find("\\%s" % c) != -1:
 456                     if supported:
 457                         document.header[p] = "\\use_package " + pkg + " 2"
 458                     else:
 459                         add_to_preamble(document, ["\\usepackage{" + pkg + "}"])
 460                     return
 461             i = j
 462
 463
 464 mathtools_commands = ["xhookrightarrow", "xhookleftarrow", "xRightarrow", \
 465                 "xrightharpoondown", "xrightharpoonup", "xrightleftharpoons", \
 466                 "xLeftarrow", "xleftharpoondown", "xleftharpoonup", \
 467                 "xleftrightarrow", "xLeftrightarrow", "xleftrightharpoons", \
 468                 "xmapsto"]
 469
 470 def revert_xarrow(document):
 471     "remove use_package mathtools"
 472     revert_use_package(document, "mathtools", mathtools_commands, False, True)
 473
 474
 475 def revert_beamer_lemma(document):
 476     " Reverts beamer lemma layout to ERT "
 477
 478     beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
 479     if document.textclass not in beamer_classes:
 480         return
 481
 482     consecutive = False
 483     i = 0
 484     while True:
 485         i = find_token(document.body, "\\begin_layout Lemma", i)
 486         if i == -1:
 487             return
 488         j = find_end_of_layout(document.body, i)
 489         if j == -1:
 490             document.warning("Malformed LyX document: Can't find end of Lemma layout")
 491             i += 1
 492             continue
 493         arg1 = find_token(document.body, "\\begin_inset Argument 1", i, j)
 494         endarg1 = find_end_of_inset(document.body, arg1)
 495         arg2 = find_token(document.body, "\\begin_inset Argument 2", i, j)
 496         endarg2 = find_end_of_inset(document.body, arg2)
 497         subst1 = []
 498         subst2 = []
 499         if arg1 != -1:
 500             beginPlain1 = find_token(document.body, "\\begin_layout Plain Layout", arg1, endarg1)
 501             if beginPlain1 == -1:
 502                 document.warning("Malformed LyX document: Can't find arg1 plain Layout")
 503                 i += 1
 504                 continue
 505             endPlain1 = find_end_of_inset(document.body, beginPlain1)
 506             content1 = document.body[beginPlain1 + 1 : endPlain1 - 2]
 507             subst1 = put_cmd_in_ert("<") + content1 + put_cmd_in_ert(">")
 508         if arg2 != -1:
 509             beginPlain2 = find_token(document.body, "\\begin_layout Plain Layout", arg2, endarg2)
 510             if beginPlain2 == -1:
 511                 document.warning("Malformed LyX document: Can't find arg2 plain Layout")
 512                 i += 1
 513                 continue
 514             endPlain2 = find_end_of_inset(document.body, beginPlain2)
 515             content2 = document.body[beginPlain2 + 1 : endPlain2 - 2]
 516             subst2 = put_cmd_in_ert("[") + content2 + put_cmd_in_ert("]")
 517
 518         # remove Arg insets
 519         if arg1 < arg2:
 520             del document.body[arg2 : endarg2 + 1]
 521             if arg1 != -1:
 522                 del document.body[arg1 : endarg1 + 1]
 523         if arg2 < arg1:
 524             del document.body[arg1 : endarg1 + 1]
 525             if arg2 != -1:
 526                 del document.body[arg2 : endarg2 + 1]
 527
 528         # index of end layout has probably changed
 529         j = find_end_of_layout(document.body, i)
 530         if j == -1:
 531             document.warning("Malformed LyX document: Can't find end of Lemma layout")
 532             i += 1
 533             continue
 534
 535         begcmd = []
 536
 537         # if this is not a consecutive env, add start command
 538         if not consecutive:
 539             begcmd = put_cmd_in_ert("\\begin{lemma}")
 540
 541         # has this a consecutive lemma?
 542         consecutive = document.body[j + 2] == "\\begin_layout Lemma"
 543
 544         # if this is not followed by a consecutive env, add end command
 545         if not consecutive:
 546             document.body[j : j + 1] = put_cmd_in_ert("\\end{lemma}") + ["\\end_layout"]
 547
 548         document.body[i : i + 1] = ["\\begin_layout Standard", ""] + begcmd + subst1 + subst2
 549
 550         i = j
 551
 552
 553
 554 def revert_question_env(document):
 555     """
 556     Reverts question and question* environments of
 557     theorems-ams-extended-bytype module to ERT
 558     """
 559
 560     # Do we use theorems-ams-extended-bytype module?
 561     if not "theorems-ams-extended-bytype" in document.get_module_list():
 562         return
 563
 564     consecutive = False
 565     i = 0
 566     while True:
 567         i = find_token(document.body, "\\begin_layout Question", i)
 568         if i == -1:
 569             return
 570
 571         starred = document.body[i] == "\\begin_layout Question*"
 572
 573         j = find_end_of_layout(document.body, i)
 574         if j == -1:
 575             document.warning("Malformed LyX document: Can't find end of Question layout")
 576             i += 1
 577             continue
 578
 579         # if this is not a consecutive env, add start command
 580         begcmd = []
 581         if not consecutive:
 582             if starred:
 583                 begcmd = put_cmd_in_ert("\\begin{question*}")
 584             else:
 585                 begcmd = put_cmd_in_ert("\\begin{question}")
 586
 587         # has this a consecutive theorem of same type?
 588         consecutive = False
 589         if starred:
 590             consecutive = document.body[j + 2] == "\\begin_layout Question*"
 591         else:
 592             consecutive = document.body[j + 2] == "\\begin_layout Question"
 593
 594         # if this is not followed by a consecutive env, add end command
 595         if not consecutive:
 596             if starred:
 597                 document.body[j : j + 1] = put_cmd_in_ert("\\end{question*}") + ["\\end_layout"]
 598             else:
 599                 document.body[j : j + 1] = put_cmd_in_ert("\\end{question}") + ["\\end_layout"]
 600
 601         document.body[i : i + 1] = ["\\begin_layout Standard", ""] + begcmd
 602
 603         add_to_preamble(document, "\\providecommand{\questionname}{Question}")
 604
 605         if starred:
 606             add_to_preamble(document, "\\theoremstyle{plain}\n" \
 607                                       "\\newtheorem*{question*}{\\protect\\questionname}")
 608         else:
 609             add_to_preamble(document, "\\theoremstyle{plain}\n" \
 610                                       "\\newtheorem{question}{\\protect\\questionname}")
 611
 612         i = j
 613
 614
 615 def convert_dashes(document):
 616     "convert -- and --- to \\twohyphens and \\threehyphens"
 617
 618     if document.backend != "latex":
 619         return
 620
 621     i = 0
 622     while True:
 623         i = find_substring(document.body, "--", i+1)
 624         if i == -1:
 625             break
 626         line = document.body[i]
 627         # skip label width string (bug 10243):
 628         if line.startswith("\\labelwidthstring"):
 629             continue
 630         # Do not touch hyphens in some insets:
 631         try:
 632             value, start, end = get_containing_inset(document.body, i)
 633         except TypeError:
 634             # False means no (or malformed) containing inset
 635             value, start, end = "no inset", -1, -1
 636         # We must not replace anything in insets that store LaTeX contents in .lyx files
 637         # (math and command insets without overridden read() and write() methods.
 638         # Filtering out IPA and ERT makes Text::readParToken() more simple,
 639         # Flex Code is logical markup, typically rendered as typewriter
 640         if (value.split()[0] in ["CommandInset", "ERT", "External", "Formula",
 641                                  "FormulaMacro", "Graphics", "IPA", "listings"]
 642             or value in ["Flex Code", "Flex URL"]):
 643             i = end
 644             continue
 645         try:
 646             layout, start, end, j = get_containing_layout(document.body, i)
 647         except TypeError: # no (or malformed) containing layout
 648             document.warning("Malformed LyX document: "
 649                              "Can't find layout at line %d" % i)
 650             continue
 651         if layout == "LyX-Code":
 652             i = end
 653             continue
 654         # We can have an arbitrary number of consecutive hyphens.
 655         # Replace as LaTeX does: First try emdash, then endash
 656         line = line.replace("---", "\\threehyphens\n")
 657         line = line.replace("--", "\\twohyphens\n")
 658         document.body[i:i+1] = line.split('\n')
 659
 660     # remove ligature breaks between dashes
 661     i = 0
 662     while True:
 663         i = find_substring(document.body,
 664                            r"-\SpecialChar \textcompwordmark{}", i+1)
 665         if i == -1:
 666             break
 667         if document.body[i+1].startswith("-"):
 668             document.body[i] = document.body[i].replace(
 669                 r"\SpecialChar \textcompwordmark{}", document.body.pop(i+1))
 670
 671
 672 def revert_dashes(document):
 673     """
 674     Remove preamble code from 2.3->2.2 conversion.
 675     Prevent ligatures of existing --- and --.
 676     Revert \\twohyphens and \\threehyphens to -- and ---.
 677     """
 678     del_complete_lines(document.preamble,
 679                        ['% Added by lyx2lyx',
 680                         r'\renewcommand{\textendash}{--}',
 681                         r'\renewcommand{\textemdash}{---}'])
 682
 683     # Insert ligature breaks to prevent ligation of hyphens to dashes:
 684     i = 0
 685     while True:
 686         i = find_substring(document.body, "--", i+1)
 687         if i == -1:
 688             break
 689         line = document.body[i]
 690         # skip label width string (bug 10243):
 691         if line.startswith("\\labelwidthstring"):
 692             continue
 693         # do not touch hyphens in some insets (cf. convert_dashes):
 694         try:
 695             value, start, end = get_containing_inset(document.body, i)
 696         except TypeError:
 697             # False means no (or malformed) containing inset
 698             value, start, end = "no inset", -1, -1
 699         if (value.split()[0] in ["CommandInset", "ERT", "External", "Formula",
 700                                  "FormulaMacro", "Graphics", "IPA", "listings"]
 701             or value == "Flex URL"):
 702             i = end
 703             continue
 704         line = line.replace("--", "-\\SpecialChar \\textcompwordmark{}\n-")
 705         document.body[i:i+1] = line.split('\n')
 706
 707     # Revert \twohyphens and \threehyphens:
 708     i = 1
 709     while i < len(document.body):
 710         line = document.body[i]
 711         if not line.endswith("hyphens"):
 712             i +=1
 713         elif line.endswith("\\twohyphens") or line.endswith("\\threehyphens"):
 714             line = line.replace("\\twohyphens", "--")
 715             line = line.replace("\\threehyphens", "---")
 716             document.body[i] = line + document.body.pop(i+1)
 717         else:
 718             i += 1
 719
 720
 721 # order is important for the last three!
 722 phrases = ["LyX", "LaTeX2e", "LaTeX", "TeX"]
 723
 724 def is_part_of_converted_phrase(line, j, phrase):
 725     "is phrase part of an already converted phrase?"
 726     for p in phrases:
 727         converted = "\\SpecialCharNoPassThru \\" + p
 728         pos = j + len(phrase) - len(converted)
 729         if pos >= 0:
 730             if line[pos:pos+len(converted)] == converted:
 731                 return True
 732     return False
 733
 734
 735 def convert_phrases(document):
 736     "convert special phrases from plain text to \\SpecialCharNoPassThru"
 737
 738     if document.backend != "latex":
 739         return
 740
 741     for phrase in phrases:
 742         i = 0
 743         while i < len(document.body):
 744             words = document.body[i].split()
 745             if len(words) > 1 and words[0] == "\\begin_inset" and \
 746                words[1] in ["CommandInset", "External", "Formula", "Graphics", "listings"]:
 747                 # must not replace anything in insets that store LaTeX contents in .lyx files
 748                 # (math and command insets without overridden read() and write() methods)
 749                 j = find_end_of_inset(document.body, i)
 750                 if j == -1:
 751                     document.warning("Malformed LyX document: Can't find end of inset at line " + str(i))
 752                     i += 1
 753                 else:
 754                     i = j
 755                 continue
 756             if document.body[i].find("\\") == 0:
 757                 i += 1
 758                 continue
 759             j = document.body[i].find(phrase)
 760             if j == -1:
 761                 i += 1
 762                 continue
 763             if not is_part_of_converted_phrase(document.body[i], j, phrase):
 764                 front = document.body[i][:j]
 765                 back = document.body[i][j+len(phrase):]
 766                 if len(back) > 0:
 767                     document.body.insert(i+1, back)
 768                 # We cannot use SpecialChar since we do not know whether we are outside passThru
 769                 document.body[i] = front + "\\SpecialCharNoPassThru \\" + phrase
 770             i += 1
 771
 772
 773 def revert_phrases(document):
 774     "convert special phrases to plain text"
 775
 776     i = 0
 777     while i < len(document.body):
 778         words = document.body[i].split()
 779         if len(words) > 1 and words[0] == "\\begin_inset" and \
 780            words[1] in ["CommandInset", "External", "Formula", "Graphics", "listings"]:
 781             # see convert_phrases
 782             j = find_end_of_inset(document.body, i)
 783             if j == -1:
 784                 document.warning("Malformed LyX document: Can't find end of Formula inset at line " + str(i))
 785                 i += 1
 786             else:
 787                 i = j
 788             continue
 789         replaced = False
 790         for phrase in phrases:
 791             # we can replace SpecialChar since LyX ensures that it cannot be inserted into passThru parts
 792             if document.body[i].find("\\SpecialChar \\" + phrase) >= 0:
 793                 document.body[i] = document.body[i].replace("\\SpecialChar \\" + phrase, phrase)
 794                 replaced = True
 795             if document.body[i].find("\\SpecialCharNoPassThru \\" + phrase) >= 0:
 796                 document.body[i] = document.body[i].replace("\\SpecialCharNoPassThru \\" + phrase, phrase)
 797                 replaced = True
 798         if replaced and i+1 < len(document.body) and \
 799            (document.body[i+1].find("\\") != 0 or \
 800             document.body[i+1].find("\\SpecialChar") == 0) and \
 801            len(document.body[i]) + len(document.body[i+1]) <= 80:
 802             document.body[i] = document.body[i] + document.body[i+1]
 803             document.body[i+1:i+2] = []
 804             i -= 1
 805         i += 1
 806
 807
 808 def convert_specialchar_internal(document, forward):
 809     specialchars = {"\\-":"softhyphen", "\\textcompwordmark{}":"ligaturebreak", \
 810         "\\@.":"endofsentence", "\\ldots{}":"ldots", \
 811         "\\menuseparator":"menuseparator", "\\slash{}":"breakableslash", \
 812         "\\nobreakdash-":"nobreakdash", "\\LyX":"LyX", \
 813         "\\TeX":"TeX", "\\LaTeX2e":"LaTeX2e", \
 814         "\\LaTeX":"LaTeX" # must be after LaTeX2e
 815     }
 816
 817     i = 0
 818     while i < len(document.body):
 819         words = document.body[i].split()
 820         if len(words) > 1 and words[0] == "\\begin_inset" and \
 821            words[1] in ["CommandInset", "External", "Formula", "Graphics", "listings"]:
 822             # see convert_phrases
 823             j = find_end_of_inset(document.body, i)
 824             if j == -1:
 825                 document.warning("Malformed LyX document: Can't find end of Formula inset at line " + str(i))
 826                 i += 1
 827             else:
 828                 i = j
 829             continue
 830         for key, value in specialchars.items():
 831             if forward:
 832                 document.body[i] = document.body[i].replace("\\SpecialChar " + key, "\\SpecialChar " + value)
 833                 document.body[i] = document.body[i].replace("\\SpecialCharNoPassThru " + key, "\\SpecialCharNoPassThru " + value)
 834             else:
 835                 document.body[i] = document.body[i].replace("\\SpecialChar " + value, "\\SpecialChar " + key)
 836                 document.body[i] = document.body[i].replace("\\SpecialCharNoPassThru " + value, "\\SpecialCharNoPassThru " + key)
 837         i += 1
 838
 839
 840 def convert_specialchar(document):
 841     "convert special characters to new syntax"
 842     convert_specialchar_internal(document, True)
 843
 844
 845 def revert_specialchar(document):
 846     "convert special characters to old syntax"
 847     convert_specialchar_internal(document, False)
 848
 849
 850 def revert_georgian(document):
 851     "Set the document language to English but assure Georgian output"
 852
 853     if document.language == "georgian":
 854         document.language = "english"
 855         i = find_token(document.header, "\\language georgian", 0)
 856         if i != -1:
 857             document.header[i] = "\\language english"
 858         j = find_token(document.header, "\\language_package default", 0)
 859         if j != -1:
 860             document.header[j] = "\\language_package babel"
 861         k = find_token(document.header, "\\options", 0)
 862         if k != -1:
 863             document.header[k] = document.header[k].replace("\\options", "\\options georgian,")
 864         else:
 865             l = find_token(document.header, "\\use_default_options", 0)
 866             document.header.insert(l + 1, "\\options georgian")
 867
 868
 869 def revert_sigplan_doi(document):
 870     " Reverts sigplanconf DOI layout to ERT "
 871
 872     if document.textclass != "sigplanconf":
 873         return
 874
 875     i = 0
 876     while True:
 877         i = find_token(document.body, "\\begin_layout DOI", i)
 878         if i == -1:
 879             return
 880         j = find_end_of_layout(document.body, i)
 881         if j == -1:
 882             document.warning("Malformed LyX document: Can't find end of DOI layout")
 883             i += 1
 884             continue
 885
 886         content = lyx2latex(document, document.body[i:j + 1])
 887         add_to_preamble(document, ["\\doi{" + content + "}"])
 888         del document.body[i:j + 1]
 889         # no need to reset i
 890
 891
 892 def revert_ex_itemargs(document):
 893     " Reverts \\item arguments of the example environments (Linguistics module) to TeX-code "
 894
 895     if not "linguistics" in document.get_module_list():
 896         return
 897
 898     i = 0
 899     example_layouts = ["Numbered Examples (consecutive)", "Subexample"]
 900     while True:
 901         i = find_token(document.body, "\\begin_inset Argument item:", i)
 902         if i == -1:
 903             return
 904         j = find_end_of_inset(document.body, i)
 905         # Find containing paragraph layout
 906         parent = get_containing_layout(document.body, i)
 907         if parent == False:
 908             document.warning("Malformed LyX document: Can't find parent paragraph layout")
 909             i += 1
 910             continue
 911         parbeg = parent[3]
 912         layoutname = parent[0]
 913         if layoutname in example_layouts:
 914             beginPlain = find_token(document.body, "\\begin_layout Plain Layout", i)
 915             endPlain = find_end_of_layout(document.body, beginPlain)
 916             content = document.body[beginPlain + 1 : endPlain]
 917             del document.body[i:j+1]
 918             subst = put_cmd_in_ert("[") + content + put_cmd_in_ert("]")
 919             document.body[parbeg : parbeg] = subst
 920         i += 1
 921
 922
 923 def revert_forest(document):
 924     " Reverts the forest environment (Linguistics module) to TeX-code "
 925
 926     if not "linguistics" in document.get_module_list():
 927         return
 928
 929     i = 0
 930     while True:
 931         i = find_token(document.body, "\\begin_inset Flex Structure Tree", i)
 932         if i == -1:
 933             return
 934         j = find_end_of_inset(document.body, i)
 935         if j == -1:
 936             document.warning("Malformed LyX document: Can't find end of Structure Tree inset")
 937             i += 1
 938             continue
 939
 940         beginPlain = find_token(document.body, "\\begin_layout Plain Layout", i)
 941         endPlain = find_end_of_layout(document.body, beginPlain)
 942         content = lyx2latex(document, document.body[beginPlain : endPlain])
 943
 944         add_to_preamble(document, ["\\usepackage{forest}"])
 945
 946         document.body[i:j + 1] = put_cmd_in_ert("\\begin{forest}" + content + "\\end{forest}")
 947         # no need to reset i
 948
 949
 950 def revert_glossgroup(document):
 951     " Reverts the GroupGlossedWords inset (Linguistics module) to TeX-code "
 952
 953     if not "linguistics" in document.get_module_list():
 954         return
 955
 956     i = 0
 957     while True:
 958         i = find_token(document.body, "\\begin_inset Flex GroupGlossedWords", i)
 959         if i == -1:
 960             return
 961         j = find_end_of_inset(document.body, i)
 962         if j == -1:
 963             document.warning("Malformed LyX document: Can't find end of GroupGlossedWords inset")
 964             i += 1
 965             continue
 966
 967         beginPlain = find_token(document.body, "\\begin_layout Plain Layout", i)
 968         endPlain = find_end_of_layout(document.body, beginPlain)
 969         content = lyx2verbatim(document, document.body[beginPlain : endPlain])
 970
 971         document.body[i:j + 1] = ["{", "", content, "", "}"]
 972         # no need to reset i
 973
 974
 975 def revert_newgloss(document):
 976     " Reverts the new Glosse insets (Linguistics module) to the old format "
 977
 978     if not "linguistics" in document.get_module_list():
 979         return
 980
 981     glosses = ("\\begin_inset Flex Glosse", "\\begin_inset Flex Tri-Glosse")
 982     for glosse in glosses:
 983         i = 0
 984         while True:
 985             i = find_token(document.body, glosse, i)
 986             if i == -1:
 987                 break
 988             j = find_end_of_inset(document.body, i)
 989             if j == -1:
 990                 document.warning("Malformed LyX document: Can't find end of Glosse inset")
 991                 i += 1
 992                 continue
 993
 994             arg = find_token(document.body, "\\begin_inset Argument 1", i, j)
 995             endarg = find_end_of_inset(document.body, arg)
 996             argcontent = ""
 997             if arg != -1:
 998                 argbeginPlain = find_token(document.body, "\\begin_layout Plain Layout", arg, endarg)
 999                 if argbeginPlain == -1:
1000                     document.warning("Malformed LyX document: Can't find arg plain Layout")
1001                     i += 1
1002                     continue
1003                 argendPlain = find_end_of_inset(document.body, argbeginPlain)
1004                 argcontent = lyx2verbatim(document, document.body[argbeginPlain : argendPlain - 2])
1005
1006                 document.body[j:j] = ["", "\\begin_layout Plain Layout","\\backslash", "glt ",
1007                     argcontent, "\\end_layout"]
1008
1009                 # remove Arg insets and paragraph, if it only contains this inset
1010                 if document.body[arg - 1] == "\\begin_layout Plain Layout" and find_end_of_layout(document.body, arg - 1) == endarg + 3:
1011                     del document.body[arg - 1 : endarg + 4]
1012                 else:
1013                     del document.body[arg : endarg + 1]
1014
1015             beginPlain = find_token(document.body, "\\begin_layout Plain Layout", i)
1016             endPlain = find_end_of_layout(document.body, beginPlain)
1017             content = lyx2verbatim(document, document.body[beginPlain : endPlain])
1018
1019             document.body[beginPlain + 1:endPlain] = [content]
1020             i = beginPlain + 1
1021
1022     # Dissolve ERT insets
1023     for glosse in glosses:
1024         i = 0
1025         while True:
1026             i = find_token(document.body, glosse, i)
1027             if i == -1:
1028                 break
1029             j = find_end_of_inset(document.body, i)
1030             if j == -1:
1031                 document.warning("Malformed LyX document: Can't find end of Glosse inset")
1032                 i += 1
1033                 continue
1034             while True:
1035                 ert = find_token(document.body, "\\begin_inset ERT", i, j)
1036                 if ert == -1:
1037                     break
1038                 ertend = find_end_of_inset(document.body, ert)
1039                 if ertend == -1:
1040                     document.warning("Malformed LyX document: Can't find end of ERT inset")
1041                     ert += 1
1042                     continue
1043                 ertcontent = get_ert(document.body, ert, True)
1044                 document.body[ert : ertend + 1] = [ertcontent]
1045             i += 1
1046
1047
1048 def convert_newgloss(document):
1049     " Converts Glosse insets (Linguistics module) to the new format "
1050
1051     if not "linguistics" in document.get_module_list():
1052         return
1053
1054     glosses = ("\\begin_inset Flex Glosse", "\\begin_inset Flex Tri-Glosse")
1055     for glosse in glosses:
1056         i = 0
1057         while True:
1058             i = find_token(document.body, glosse, i)
1059             if i == -1:
1060                 break
1061             j = find_end_of_inset(document.body, i)
1062             if j == -1:
1063                 document.warning("Malformed LyX document: Can't find end of Glosse inset")
1064                 i += 1
1065                 continue
1066
1067             k = i
1068             while True:
1069                 argcontent = []
1070                 beginPlain = find_token(document.body, "\\begin_layout Plain Layout", k, j)
1071                 if beginPlain == -1:
1072                     break
1073                 endPlain = find_end_of_layout(document.body, beginPlain)
1074                 if endPlain == -1:
1075                     document.warning("Malformed LyX document: Can't find end of Glosse layout")
1076                     i += 1
1077                     continue
1078
1079                 glt  = find_token(document.body, "\\backslash", beginPlain, endPlain)
1080                 if glt != -1 and document.body[glt + 1].startswith("glt"):
1081                     document.body[glt + 1] = document.body[glt + 1].lstrip("glt").lstrip()
1082                     argcontent = document.body[glt + 1 : endPlain]
1083                     document.body[beginPlain + 1 : endPlain] = ["\\begin_inset Argument 1", "status open", "",
1084                         "\\begin_layout Plain Layout", "\\begin_inset ERT", "status open", "",
1085                         "\\begin_layout Plain Layout", ""] + argcontent + ["\\end_layout", "", "\\end_inset", "",
1086                         "\\end_layout", "", "\\end_inset"]
1087                 else:
1088                     content = document.body[beginPlain + 1 : endPlain]
1089                     document.body[beginPlain + 1 : endPlain] = ["\\begin_inset ERT", "status open", "",
1090                         "\\begin_layout Plain Layout"] + content + ["\\end_layout", "", "\\end_inset"]
1091
1092                 endPlain = find_end_of_layout(document.body, beginPlain)
1093                 k = endPlain
1094                 j = find_end_of_inset(document.body, i)
1095
1096             i = endPlain + 1
1097
1098
1099 def convert_BoxFeatures(document):
1100     " adds new box features "
1101
1102     i = 0
1103     while True:
1104         i = find_token(document.body, "height_special", i)
1105         if i == -1:
1106             return
1107         document.body[i+1:i+1] = ['thickness "0.4pt"', 'separation "3pt"', 'shadowsize "4pt"']
1108         i = i + 4
1109
1110
1111 def revert_BoxFeatures(document):
1112     " outputs new box features as TeX code "
1113
1114     i = 0
1115     defaultSep = "3pt"
1116     defaultThick = "0.4pt"
1117     defaultShadow = "4pt"
1118     while True:
1119         i = find_token(document.body, "thickness", i)
1120         if i == -1:
1121             return
1122         binset = find_token(document.body, "\\begin_inset Box", i - 11)
1123         if binset == -1 or binset != i - 11:
1124             i = i + 1
1125             continue # then "thickness" is is just a word in the text
1126         einset = find_end_of_inset(document.body, binset)
1127         if einset == -1:
1128             document.warning("Malformed LyX document: Can't find end of box inset!")
1129             i = i + 1
1130             continue
1131         # read out the values
1132         beg = document.body[i].find('"');
1133         end = document.body[i].rfind('"');
1134         thickness = document.body[i][beg+1:end];
1135         beg = document.body[i+1].find('"');
1136         end = document.body[i+1].rfind('"');
1137         separation = document.body[i+1][beg+1:end];
1138         beg = document.body[i+2].find('"');
1139         end = document.body[i+2].rfind('"');
1140         shadowsize = document.body[i+2][beg+1:end];
1141         # delete the specification
1142         del document.body[i:i+3]
1143         # output ERT
1144         # first output the closing brace
1145         if shadowsize != defaultShadow or separation != defaultSep or thickness != defaultThick:
1146             document.body[einset -1 : einset - 1] = put_cmd_in_ert("}")
1147         # we have now the problem that if there is already \(f)colorbox in ERT around the inset
1148         # the ERT from this routine must be around it
1149         regexp = re.compile(r'^.*colorbox{.*$')
1150         pos = find_re(document.body, regexp, binset - 4)
1151         if pos != -1 and pos == binset - 4:
1152             pos = i - 11 - 10
1153         else:
1154             pos = i - 11
1155         # now output the lengths
1156         if shadowsize != defaultShadow or separation != defaultSep or thickness != defaultThick:
1157             document.body[pos : pos] = put_cmd_in_ert("{")
1158         if thickness != defaultThick:
1159             document.body[pos + 5 : pos +6] = ["{\\backslash fboxrule " + thickness]
1160         if separation != defaultSep and thickness == defaultThick:
1161             document.body[pos + 5 : pos +6] = ["{\\backslash fboxsep " + separation]
1162         if separation != defaultSep and thickness != defaultThick:
1163             document.body[pos + 5 : pos +6] = ["{\\backslash fboxrule " + thickness + "\\backslash fboxsep " + separation]
1164         if shadowsize != defaultShadow and separation == defaultSep and thickness == defaultThick:
1165             document.body[pos + 5 : pos +6] = ["{\\backslash shadowsize " + shadowsize]
1166         if shadowsize != defaultShadow and separation != defaultSep and thickness == defaultThick:
1167             document.body[pos + 5 : pos +6] = ["{\\backslash fboxsep " + separation + "\\backslash shadowsize " + shadowsize]
1168         if shadowsize != defaultShadow and separation == defaultSep and thickness != defaultThick:
1169             document.body[pos + 5 : pos +6] = ["{\\backslash fboxrule " + thickness + "\\backslash shadowsize " + shadowsize]
1170         if shadowsize != defaultShadow and separation != defaultSep and thickness != defaultThick:
1171             document.body[pos + 5 : pos +6] = ["{\\backslash fboxrule " + thickness + "\\backslash fboxsep " + separation + "\\backslash shadowsize " + shadowsize]
1172
1173
1174 def convert_origin(document):
1175     " Insert the origin tag "
1176
1177     i = find_token(document.header, "\\textclass ", 0)
1178     if i == -1:
1179         document.warning("Malformed LyX document: No \\textclass!!")
1180         return
1181     if document.dir == u'':
1182         origin = u'stdin'
1183     else:
1184         relpath = u''
1185         if document.systemlyxdir and document.systemlyxdir != u'':
1186             try:
1187                 if os.path.isabs(document.dir):
1188                     absdir = os.path.normpath(document.dir)
1189                 else:
1190                     absdir = os.path.normpath(os.path.abspath(document.dir))
1191                 if os.path.isabs(document.systemlyxdir):
1192                     abssys = os.path.normpath(document.systemlyxdir)
1193                 else:
1194                     abssys = os.path.normpath(os.path.abspath(document.systemlyxdir))
1195                 relpath = os.path.relpath(absdir, abssys)
1196                 if relpath.find(u'..') == 0:
1197                     relpath = u''
1198             except:
1199                 relpath = u''
1200         if relpath == u'':
1201             origin = document.dir.replace(u'\\', u'/') + u'/'
1202         else:
1203             origin = os.path.join(u"/systemlyxdir", relpath).replace(u'\\', u'/') + u'/'
1204     document.header[i:i] = ["\\origin " + origin]
1205
1206
1207 def revert_origin(document):
1208     " Remove the origin tag "
1209
1210     i = find_token(document.header, "\\origin ", 0)
1211     if i == -1:
1212         document.warning("Malformed LyX document: No \\origin!!")
1213         return
1214     del document.header[i]
1215
1216
1217 color_names = ["brown", "darkgray", "gray", \
1218                "lightgray", "lime", "olive", "orange", \
1219                "pink", "purple", "teal", "violet"]
1220
1221 def revert_textcolor(document):
1222     " revert new \\textcolor colors to TeX code "
1223
1224     i = 0
1225     j = 0
1226     xcolor = False
1227     while True:
1228         i = find_token(document.body, "\\color ", i)
1229         if i == -1:
1230             return
1231         else:
1232             for color in list(color_names):
1233                 if document.body[i] == "\\color " + color:
1234                     # register that xcolor must be loaded in the preamble
1235                     if xcolor == False:
1236                         xcolor = True
1237                         add_to_preamble(document, ["\\@ifundefined{rangeHsb}{\\usepackage{xcolor}}{}"])
1238                     # find the next \\color and/or the next \\end_layout
1239                     j = find_token(document.body, "\\color", i + 1)
1240                     k = find_token(document.body, "\\end_layout", i + 1)
1241                     if j == -1 and k != -1:
1242                         j = k +1
1243                     # output TeX code
1244                     # first output the closing brace
1245                     if k < j:
1246                         document.body[k: k] = put_cmd_in_ert("}")
1247                     else:
1248                         document.body[j: j] = put_cmd_in_ert("}")
1249                     # now output the \textcolor command
1250                     document.body[i : i + 1] = put_cmd_in_ert("\\textcolor{" + color + "}{")
1251         i = i + 1
1252
1253
1254 def convert_colorbox(document):
1255     "Add color settings for boxes."
1256     i = 1
1257     while True:
1258         i = find_token(document.body, "shadowsize", i)
1259         if i == -1:
1260             return
1261         # check whether this is really a LyX Box setting
1262         start, end = is_in_inset(document.body, i, "\\begin_inset Box")
1263         if (end == -1 or
1264             find_token(document.body, "\\begin_layout", start, i) != -1):
1265             i += 1
1266             continue
1267         document.body[i+1:i+1] = ['framecolor "black"',
1268                                   'backgroundcolor "none"']
1269         i += 3
1270
1271
1272 def revert_colorbox(document):
1273     """Change box color settings to LaTeX code."""
1274
1275     i = 0
1276     while True:
1277         i = find_token(document.body, "\\begin_inset Box", i+1)
1278         if i == -1:
1279             return
1280         # Get and delete colour settings:
1281         framecolor = get_quoted_value(document.body, "framecolor", i+14, i+15, delete=True)
1282         backcolor = get_quoted_value(document.body, "backgroundcolor", i+14, i+15, delete=True)
1283         if not framecolor or not backcolor:
1284             document.warning("Malformed LyX document: color options not found in Box inset!")
1285             continue
1286         if framecolor == "black" and backcolor == "none": # default values
1287             i += 15 # skip box option lines
1288             continue
1289
1290         # Emulate non-default colours with LaTeX code:
1291         einset = find_end_of_inset(document.body, i)
1292         if einset == -1:
1293             document.warning("Malformed LyX document: Can't find end of box inset!")
1294             continue
1295         add_to_preamble(document, ["\\@ifundefined{rangeHsb}{\\usepackage{xcolor}}{}"])
1296         # insert the closing brace first (keeps indices 'i' and 'einset' valid)
1297         document.body[einset+1:einset+1] = put_cmd_in_ert("}") + [""]
1298         # now insert the (f)color box command
1299         if ("Box Boxed" in document.body[i]): # framed box, use \fcolorbox
1300             # change the box type (frame added by \fcolorbox)
1301             document.body[i] = "\\begin_inset Box Frameless"
1302             # ensure an inner box:
1303             try:
1304                 if not set_bool_value(document.body, "has_inner_box", True, i+3, i+4):
1305                     set_bool_value(document.body, "use_makebox", True, i+6, i+7)
1306             except ValueError:
1307                 document.warning("Malformed LyX document: 'has_inner_box' or "
1308                                  "'use_makebox' option not found in box inset!")
1309             ertinset = put_cmd_in_ert("\\fcolorbox{%s}{%s}{"% (framecolor, backcolor))
1310         else:
1311             ertinset = put_cmd_in_ert("\\colorbox{%s}{" % backcolor)
1312         document.body[i:i] = ertinset + [""]
1313         i = einset # skip inset
1314
1315
1316 def revert_mathmulticol(document):
1317     " Convert formulas to ERT if they contain multicolumns "
1318
1319     i = 0
1320     while True:
1321         i = find_token(document.body, '\\begin_inset Formula', i)
1322         if i == -1:
1323             return
1324         j = find_end_of_inset(document.body, i)
1325         if j == -1:
1326             document.warning("Malformed LyX document: Can't find end of Formula inset at line " + str(i))
1327             i += 1
1328             continue
1329         lines = document.body[i:j]
1330         lines[0] = lines[0].replace('\\begin_inset Formula', '').lstrip()
1331         code = "\n".join(lines)
1332         converted = False
1333         k = 0
1334         n = 0
1335         while n >= 0:
1336             n = code.find("\\multicolumn", k)
1337             # no need to convert degenerated multicolumn cells,
1338             # they work in old LyX versions as "math ERT"
1339             if n != -1 and code.find("\\multicolumn{1}", k) != n:
1340                 ert = put_cmd_in_ert(code)
1341                 document.body[i:j+1] = ert
1342                 converted = True
1343                 break
1344             else:
1345                 k = n + 12
1346         if converted:
1347             i = find_end_of_inset(document.body, i)
1348         else:
1349             i = j
1350
1351
1352 def revert_jss(document):
1353     " Reverts JSS In_Preamble commands to ERT in preamble "
1354
1355     if document.textclass != "jss":
1356         return
1357
1358     h = 0
1359     m = 0
1360     j = 0
1361     k = 0
1362     n = 0
1363     while True:
1364       # at first revert the inset layouts because they can be part of the In_Preamble layouts
1365       while m != -1 or j != -1 or h != -1 or k != -1 or n != -1:
1366         # \pkg
1367         if h != -1:
1368           h = find_token(document.body, "\\begin_inset Flex Pkg", h)
1369         if h != -1:
1370           endh = find_end_of_inset(document.body, h)
1371           document.body[endh - 2 : endh + 1] = put_cmd_in_ert("}")
1372           document.body[h : h + 4] = put_cmd_in_ert("\\pkg{")
1373           h = h + 5
1374         # \proglang
1375         if m != -1:
1376           m = find_token(document.body, "\\begin_inset Flex Proglang", m)
1377         if m != -1:
1378           endm = find_end_of_inset(document.body, m)
1379           document.body[endm - 2 : endm + 1] = put_cmd_in_ert("}")
1380           document.body[m : m + 4] = put_cmd_in_ert("\\proglang{")
1381           m = m + 5
1382         # \code
1383         if j != -1:
1384           j = find_token(document.body, "\\begin_inset Flex Code", j)
1385         if j != -1:
1386           # assure that we are not in a Code Chunk inset
1387           if document.body[j][-1] == "e":
1388               endj = find_end_of_inset(document.body, j)
1389               document.body[endj - 2 : endj + 1] = put_cmd_in_ert("}")
1390               document.body[j : j + 4] = put_cmd_in_ert("\\code{")
1391               j = j + 5
1392           else:
1393               j = j + 1
1394         # \email
1395         if k != -1:
1396           k = find_token(document.body, "\\begin_inset Flex E-mail", k)
1397         if k != -1:
1398           endk = find_end_of_inset(document.body, k)
1399           document.body[endk - 2 : endk + 1] = put_cmd_in_ert("}")
1400           document.body[k : k + 4] = put_cmd_in_ert("\\email{")
1401           k = k + 5
1402         # \url
1403         if n != -1:
1404           n = find_token(document.body, "\\begin_inset Flex URL", n)
1405         if n != -1:
1406           endn = find_end_of_inset(document.body, n)
1407           document.body[endn - 2 : endn + 1] = put_cmd_in_ert("}")
1408           document.body[n : n + 4] = put_cmd_in_ert("\\url{")
1409           n = n + 5
1410       # now revert the In_Preamble layouts
1411       # \title
1412       i = find_token(document.body, "\\begin_layout Title", 0)
1413       if i == -1:
1414         return
1415       j = find_end_of_layout(document.body, i)
1416       if j == -1:
1417         document.warning("Malformed LyX document: Can't find end of Title layout")
1418         i += 1
1419         continue
1420       content = lyx2latex(document, document.body[i:j + 1])
1421       add_to_preamble(document, ["\\title{" + content + "}"])
1422       del document.body[i:j + 1]
1423       # \author
1424       i = find_token(document.body, "\\begin_layout Author", 0)
1425       if i == -1:
1426         return
1427       j = find_end_of_layout(document.body, i)
1428       if j == -1:
1429         document.warning("Malformed LyX document: Can't find end of Author layout")
1430         i += 1
1431         continue
1432       content = lyx2latex(document, document.body[i:j + 1])
1433       add_to_preamble(document, ["\\author{" + content + "}"])
1434       del document.body[i:j + 1]
1435       # \Plainauthor
1436       i = find_token(document.body, "\\begin_layout Plain Author", 0)
1437       if i == -1:
1438         return
1439       j = find_end_of_layout(document.body, i)
1440       if j == -1:
1441         document.warning("Malformed LyX document: Can't find end of Plain Author layout")
1442         i += 1
1443         continue
1444       content = lyx2latex(document, document.body[i:j + 1])
1445       add_to_preamble(document, ["\\Plainauthor{" + content + "}"])
1446       del document.body[i:j + 1]
1447       # \Plaintitle
1448       i = find_token(document.body, "\\begin_layout Plain Title", 0)
1449       if i == -1:
1450         return
1451       j = find_end_of_layout(document.body, i)
1452       if j == -1:
1453         document.warning("Malformed LyX document: Can't find end of Plain Title layout")
1454         i += 1
1455         continue
1456       content = lyx2latex(document, document.body[i:j + 1])
1457       add_to_preamble(document, ["\\Plaintitle{" + content + "}"])
1458       del document.body[i:j + 1]
1459       # \Shorttitle
1460       i = find_token(document.body, "\\begin_layout Short Title", 0)
1461       if i == -1:
1462         return
1463       j = find_end_of_layout(document.body, i)
1464       if j == -1:
1465         document.warning("Malformed LyX document: Can't find end of Short Title layout")
1466         i += 1
1467         continue
1468       content = lyx2latex(document, document.body[i:j + 1])
1469       add_to_preamble(document, ["\\Shorttitle{" + content + "}"])
1470       del document.body[i:j + 1]
1471       # \Abstract
1472       i = find_token(document.body, "\\begin_layout Abstract", 0)
1473       if i == -1:
1474         return
1475       j = find_end_of_layout(document.body, i)
1476       if j == -1:
1477         document.warning("Malformed LyX document: Can't find end of Abstract layout")
1478         i += 1
1479         continue
1480       content = lyx2latex(document, document.body[i:j + 1])
1481       add_to_preamble(document, ["\\Abstract{" + content + "}"])
1482       del document.body[i:j + 1]
1483       # \Keywords
1484       i = find_token(document.body, "\\begin_layout Keywords", 0)
1485       if i == -1:
1486         return
1487       j = find_end_of_layout(document.body, i)
1488       if j == -1:
1489         document.warning("Malformed LyX document: Can't find end of Keywords layout")
1490         i += 1
1491         continue
1492       content = lyx2latex(document, document.body[i:j + 1])
1493       add_to_preamble(document, ["\\Keywords{" + content + "}"])
1494       del document.body[i:j + 1]
1495       # \Plainkeywords
1496       i = find_token(document.body, "\\begin_layout Plain Keywords", 0)
1497       if i == -1:
1498         return
1499       j = find_end_of_layout(document.body, i)
1500       if j == -1:
1501         document.warning("Malformed LyX document: Can't find end of Plain Keywords layout")
1502         i += 1
1503         continue
1504       content = lyx2latex(document, document.body[i:j + 1])
1505       add_to_preamble(document, ["\\Plainkeywords{" + content + "}"])
1506       del document.body[i:j + 1]
1507       # \Address
1508       i = find_token(document.body, "\\begin_layout Address", 0)
1509       if i == -1:
1510         return
1511       j = find_end_of_layout(document.body, i)
1512       if j == -1:
1513         document.warning("Malformed LyX document: Can't find end of Address layout")
1514         i += 1
1515         continue
1516       content = lyx2latex(document, document.body[i:j + 1])
1517       add_to_preamble(document, ["\\Address{" + content + "}"])
1518       del document.body[i:j + 1]
1519       # finally handle the code layouts
1520       h = 0
1521       m = 0
1522       j = 0
1523       k = 0
1524       while m != -1 or j != -1 or h != -1 or k != -1:
1525         # \CodeChunk
1526         if h != -1:
1527           h = find_token(document.body, "\\begin_inset Flex Code Chunk", h)
1528         if h != -1:
1529           endh = find_end_of_inset(document.body, h)
1530           document.body[endh : endh + 1] = put_cmd_in_ert("\\end{CodeChunk}")
1531           document.body[h : h + 3] = put_cmd_in_ert("\\begin{CodeChunk}")
1532           document.body[h - 1 : h] = ["\\begin_layout Standard"]
1533           h = h + 1
1534         # \CodeInput
1535         if j != -1:
1536           j = find_token(document.body, "\\begin_layout Code Input", j)
1537         if j != -1:
1538           endj = find_end_of_layout(document.body, j)
1539           document.body[endj : endj + 1] = ["\\end_layout", "", "\\begin_layout Standard"]
1540           document.body[endj + 3 : endj + 4] = put_cmd_in_ert("\\end{CodeInput}")
1541           document.body[endj + 13 : endj + 13] = ["\\end_layout", "", "\\begin_layout Standard"]
1542           document.body[j + 1 : j] = ["\\end_layout", "", "\\begin_layout Standard"]
1543           document.body[j : j + 1] = put_cmd_in_ert("\\begin{CodeInput}")
1544           j = j + 1
1545         # \CodeOutput
1546         if k != -1:
1547           k = find_token(document.body, "\\begin_layout Code Output", k)
1548         if k != -1:
1549           endk = find_end_of_layout(document.body, k)
1550           document.body[endk : endk + 1] = ["\\end_layout", "", "\\begin_layout Standard"]
1551           document.body[endk + 3 : endk + 4] = put_cmd_in_ert("\\end{CodeOutput}")
1552           document.body[endk + 13 : endk + 13] = ["\\end_layout", "", "\\begin_layout Standard"]
1553           document.body[k + 1 : k] = ["\\end_layout", "", "\\begin_layout Standard"]
1554           document.body[k : k + 1] = put_cmd_in_ert("\\begin{CodeOutput}")
1555           k = k + 1
1556         # \Code
1557         if m != -1:
1558           m = find_token(document.body, "\\begin_layout Code", m)
1559         if m != -1:
1560           endm = find_end_of_layout(document.body, m)
1561           document.body[endm : endm + 1] = ["\\end_layout", "", "\\begin_layout Standard"]
1562           document.body[endm + 3 : endm + 4] = put_cmd_in_ert("\\end{Code}")
1563           document.body[endm + 13 : endm + 13] = ["\\end_layout", "", "\\begin_layout Standard"]
1564           document.body[m + 1 : m] = ["\\end_layout", "", "\\begin_layout Standard"]
1565           document.body[m : m + 1] = put_cmd_in_ert("\\begin{Code}")
1566           m = m + 1
1567
1568
1569 def convert_subref(document):
1570     " converts sub: ref prefixes to subref: "
1571
1572     # 1) label insets
1573     rx = re.compile(r'^name \"sub:(.+)$')
1574     i = 0
1575     while True:
1576         i = find_token(document.body, "\\begin_inset CommandInset label", i)
1577         if i == -1:
1578             break
1579         j = find_end_of_inset(document.body, i)
1580         if j == -1:
1581             document.warning("Malformed LyX document: Can't find end of Label inset at line " + str(i))
1582             i += 1
1583             continue
1584
1585         for p in range(i, j):
1586             m = rx.match(document.body[p])
1587             if m:
1588                 label = m.group(1)
1589                 document.body[p] = "name \"subsec:" + label
1590         i += 1
1591
1592     # 2) xref insets
1593     rx = re.compile(r'^reference \"sub:(.+)$')
1594     i = 0
1595     while True:
1596         i = find_token(document.body, "\\begin_inset CommandInset ref", i)
1597         if i == -1:
1598             return
1599         j = find_end_of_inset(document.body, i)
1600         if j == -1:
1601             document.warning("Malformed LyX document: Can't find end of Ref inset at line " + str(i))
1602             i += 1
1603             continue
1604
1605         for p in range(i, j):
1606             m = rx.match(document.body[p])
1607             if m:
1608                 label = m.group(1)
1609                 document.body[p] = "reference \"subsec:" + label
1610                 break
1611         i += 1
1612
1613
1614
1615 def revert_subref(document):
1616     " reverts subref: ref prefixes to sub: "
1617
1618     # 1) label insets
1619     rx = re.compile(r'^name \"subsec:(.+)$')
1620     i = 0
1621     while True:
1622         i = find_token(document.body, "\\begin_inset CommandInset label", i)
1623         if i == -1:
1624             break
1625         j = find_end_of_inset(document.body, i)
1626         if j == -1:
1627             document.warning("Malformed LyX document: Can't find end of Label inset at line " + str(i))
1628             i += 1
1629             continue
1630
1631         for p in range(i, j):
1632             m = rx.match(document.body[p])
1633             if m:
1634                 label = m.group(1)
1635                 document.body[p] = "name \"sub:" + label
1636                 break
1637         i += 1
1638
1639     # 2) xref insets
1640     rx = re.compile(r'^reference \"subsec:(.+)$')
1641     i = 0
1642     while True:
1643         i = find_token(document.body, "\\begin_inset CommandInset ref", i)
1644         if i == -1:
1645             return
1646         j = find_end_of_inset(document.body, i)
1647         if j == -1:
1648             document.warning("Malformed LyX document: Can't find end of Ref inset at line " + str(i))
1649             i += 1
1650             continue
1651
1652         for p in range(i, j):
1653             m = rx.match(document.body[p])
1654             if m:
1655                 label = m.group(1)
1656                 document.body[p] = "reference \"sub:" + label
1657                 break
1658         i += 1
1659
1660
1661 def convert_nounzip(document):
1662     " remove the noUnzip parameter of graphics insets "
1663
1664     rx = re.compile(r'\s*noUnzip\s*$')
1665     i = 0
1666     while True:
1667         i = find_token(document.body, "\\begin_inset Graphics", i)
1668         if i == -1:
1669             break
1670         j = find_end_of_inset(document.body, i)
1671         if j == -1:
1672             document.warning("Malformed LyX document: Can't find end of graphics inset at line " + str(i))
1673             i += 1
1674             continue
1675
1676         k = find_re(document.body, rx, i, j)
1677         if k != -1:
1678           del document.body[k]
1679           j = j - 1
1680         i = j + 1
1681
1682
1683 def convert_revert_external_bbox(document, forward):
1684     " add units to bounding box of external insets "
1685
1686     rx = re.compile(r'^\s*boundingBox\s+\S+\s+\S+\s+\S+\s+\S+\s*$')
1687     i = 0
1688     while True:
1689         i = find_token(document.body, "\\begin_inset External", i)
1690         if i == -1:
1691             break
1692         j = find_end_of_inset(document.body, i)
1693         if j == -1:
1694             document.warning("Malformed LyX document: Can't find end of external inset at line " + str(i))
1695             i += 1
1696             continue
1697         k = find_re(document.body, rx, i, j)
1698         if k == -1:
1699             i = j + 1
1700             continue
1701         tokens = document.body[k].split()
1702         if forward:
1703             for t in range(1, 5):
1704                 tokens[t] += "bp"
1705         else:
1706             for t in range(1, 5):
1707                 tokens[t] = length_in_bp(tokens[t])
1708         document.body[k] = "\tboundingBox " + tokens[1] + " " + tokens[2] + " " + \
1709                            tokens[3] + " " + tokens[4]
1710         i = j + 1
1711
1712
1713 def convert_external_bbox(document):
1714     convert_revert_external_bbox(document, True)
1715
1716
1717 def revert_external_bbox(document):
1718     convert_revert_external_bbox(document, False)
1719
1720
1721 def revert_tcolorbox_1(document):
1722   " Reverts the Flex:Subtitle inset of tcolorbox to TeX-code "
1723   i = -1
1724   while True:
1725     i = find_token(document.header, "tcolorbox", i)
1726     if i == -1:
1727       break
1728     else:
1729       flex = 0
1730       flexEnd = -1
1731       flex = find_token(document.body, "\\begin_inset Flex Subtitle", flex)
1732       if flex == -1:
1733         return flexEnd
1734       flexEnd = find_end_of_inset(document.body, flex)
1735       wasOpt = revert_Argument_to_TeX_brace(document, flex, flexEnd, 1, 1, False, True, False)
1736       revert_Argument_to_TeX_brace(document, flex, 0, 2, 2, False, False, False)
1737       flexEnd = find_end_of_inset(document.body, flex)
1738       if wasOpt == True:
1739         document.body[flex + 0 : flex + 4] = put_cmd_in_ert("\\tcbsubtitle")
1740       else:
1741         document.body[flex + 0 : flex + 4] = put_cmd_in_ert("\\tcbsubtitle{")
1742       document.body[flexEnd + 4 : flexEnd + 7] = put_cmd_in_ert("}")
1743       flex += 1
1744
1745
1746 def revert_tcolorbox_2(document):
1747   " Reverts the Flex:Raster_Color_Box inset of tcolorbox to TeX-code "
1748   i = -1
1749   while True:
1750     i = find_token(document.header, "tcolorbox", i)
1751     if i == -1:
1752       break
1753     else:
1754       flex = 0
1755       flexEnd = -1
1756       flex = find_token(document.body, "\\begin_inset Flex Raster Color Box", flex)
1757       if flex == -1:
1758         return flexEnd
1759       flexEnd = find_end_of_inset(document.body, flex)
1760       revert_Argument_to_TeX_brace(document, flex, flexEnd, 1, 1, True, True, False)
1761       flexEnd = find_end_of_inset(document.body, flex)
1762       document.body[flex + 0 : flex + 4] = put_cmd_in_ert("\\begin{tcbraster}")
1763       document.body[flexEnd + 4 : flexEnd + 7] = put_cmd_in_ert("\\end{tcbraster}")
1764       flex += 1
1765
1766
1767 def revert_tcolorbox_3(document):
1768   " Reverts the Flex:Custom_Color_Box_1 inset of tcolorbox to TeX-code "
1769   i = -1
1770   while True:
1771     i = find_token(document.header, "tcolorbox", i)
1772     if i == -1:
1773       break
1774     else:
1775       flex = 0
1776       flexEnd = -1
1777       flex = find_token(document.body, "\\begin_inset Flex Custom Color Box 1", flex)
1778       if flex == -1:
1779         return flexEnd
1780       flexEnd = find_end_of_inset(document.body, flex)
1781       revert_Argument_to_TeX_brace(document, flex, flexEnd, 1, 1, True, True, False)
1782       revert_Argument_to_TeX_brace(document, flex, 0, 2, 2, True, False, False)
1783       flexEnd = find_end_of_inset(document.body, flex)
1784       document.body[flex + 0 : flex + 4] = put_cmd_in_ert("\\begin{cBoxA}")
1785       document.body[flexEnd + 4 : flexEnd + 7] = put_cmd_in_ert("{}\\end{cBoxA}")
1786       flex += 1
1787
1788
1789 def revert_tcolorbox_4(document):
1790   " Reverts the Flex:Custom_Color_Box_2 inset of tcolorbox to TeX-code "
1791   i = -1
1792   while True:
1793     i = find_token(document.header, "tcolorbox", i)
1794     if i == -1:
1795       break
1796     else:
1797       flex = 0
1798       flexEnd = -1
1799       flex = find_token(document.body, "\\begin_inset Flex Custom Color Box 2", flex)
1800       if flex == -1:
1801         return flexEnd
1802       flexEnd = find_end_of_inset(document.body, flex)
1803       revert_Argument_to_TeX_brace(document, flex, flexEnd, 1, 1, True, True, False)
1804       revert_Argument_to_TeX_brace(document, flex, 0, 2, 2, True, False, False)
1805       flexEnd = find_end_of_inset(document.body, flex)
1806       document.body[flex + 0 : flex + 4] = put_cmd_in_ert("\\begin{cBoxB}")
1807       document.body[flexEnd + 4 : flexEnd + 7] = put_cmd_in_ert("{}\\end{cBoxB}")
1808       flex += 1
1809
1810
1811 def revert_tcolorbox_5(document):
1812   " Reverts the Flex:Custom_Color_Box_3 inset of tcolorbox to TeX-code "
1813   i = -1
1814   while True:
1815     i = find_token(document.header, "tcolorbox", i)
1816     if i == -1:
1817       break
1818     else:
1819       flex = 0
1820       flexEnd = -1
1821       flex = find_token(document.body, "\\begin_inset Flex Custom Color Box 3", flex)
1822       if flex == -1:
1823         return flexEnd
1824       flexEnd = find_end_of_inset(document.body, flex)
1825       revert_Argument_to_TeX_brace(document, flex, flexEnd, 1, 1, True, True, False)
1826       revert_Argument_to_TeX_brace(document, flex, 0, 2, 2, True, False, False)
1827       flexEnd = find_end_of_inset(document.body, flex)
1828       document.body[flex + 0 : flex + 4] = put_cmd_in_ert("\\begin{cBoxC}")
1829       document.body[flexEnd + 4 : flexEnd + 7] = put_cmd_in_ert("{}\\end{cBoxC}")
1830       flex += 1
1831
1832
1833 def revert_tcolorbox_6(document):
1834   " Reverts the Flex:Custom_Color_Box_4 inset of tcolorbox to TeX-code "
1835   i = -1
1836   while True:
1837     i = find_token(document.header, "tcolorbox", i)
1838     if i == -1:
1839       break
1840     else:
1841       flex = 0
1842       flexEnd = -1
1843       flex = find_token(document.body, "\\begin_inset Flex Custom Color Box 4", flex)
1844       if flex == -1:
1845         return flexEnd
1846       flexEnd = find_end_of_inset(document.body, flex)
1847       revert_Argument_to_TeX_brace(document, flex, flexEnd, 1, 1, True, True, False)
1848       revert_Argument_to_TeX_brace(document, flex, 0, 2, 2, True, False, False)
1849       flexEnd = find_end_of_inset(document.body, flex)
1850       document.body[flex + 0 : flex + 4] = put_cmd_in_ert("\\begin{cBoxD}")
1851       document.body[flexEnd + 4 : flexEnd + 7] = put_cmd_in_ert("{}\\end{cBoxD}")
1852       flex += 1
1853
1854
1855 def revert_tcolorbox_7(document):
1856   " Reverts the Flex:Custom_Color_Box_5 inset of tcolorbox to TeX-code "
1857   i = -1
1858   while True:
1859     i = find_token(document.header, "tcolorbox", i)
1860     if i == -1:
1861       break
1862     else:
1863       flex = 0
1864       flexEnd = -1
1865       flex = find_token(document.body, "\\begin_inset Flex Custom Color Box 5", flex)
1866       if flex == -1:
1867         return flexEnd
1868       flexEnd = find_end_of_inset(document.body, flex)
1869       revert_Argument_to_TeX_brace(document, flex, flexEnd, 1, 1, True, True, False)
1870       revert_Argument_to_TeX_brace(document, flex, 0, 2, 2, True, False, False)
1871       flexEnd = find_end_of_inset(document.body, flex)
1872       document.body[flex + 0 : flex + 4] = put_cmd_in_ert("\\begin{cBoxE}")
1873       document.body[flexEnd + 4 : flexEnd + 7] = put_cmd_in_ert("{}\\end{cBoxE}")
1874       flex += 1
1875
1876
1877 def revert_tcolorbox_8(document):
1878   " Reverts the layout New Color Box Type of tcolorbox to TeX-code "
1879   i = 0
1880   j = 0
1881   k = 0
1882   while True:
1883     if i != -1:
1884       i = find_token(document.body, "\\begin_layout New Color Box Type", i)
1885     if i != -1:
1886       j = find_end_of_layout(document.body, i)
1887       wasOpt = revert_Argument_to_TeX_brace(document, i, j, 1, 1, False, True, False)
1888       revert_Argument_to_TeX_brace(document, i, 0, 2, 2, False, False, True)
1889       revert_Argument_to_TeX_brace(document, i, 0, 3, 4, False, True, False)
1890       document.body[i] = document.body[i].replace("\\begin_layout New Color Box Type", "\\begin_layout Standard")
1891       if wasOpt == True:
1892         document.body[i + 1 : i + 1] = put_cmd_in_ert("\\newtcolorbox")
1893       else:
1894         document.body[i + 1 : i + 1] = put_cmd_in_ert("\\newtcolorbox{")
1895       k = find_end_of_inset(document.body, j)
1896       k = find_token(document.body, "\\end_inset", k + 1)
1897       k = find_token(document.body, "\\end_inset", k + 1)
1898       if wasOpt == True:
1899         k = find_token(document.body, "\\end_inset", k + 1)
1900       document.body[k + 2 : j + 2] = put_cmd_in_ert("{")
1901       j = find_token(document.body, "\\begin_layout Standard", j + 1)
1902       document.body[j - 2 : j - 2] = put_cmd_in_ert("}")
1903       i += 1
1904     if i == -1:
1905       return
1906
1907
1908 def revert_moderncv_1(document):
1909   " Reverts the new inset of moderncv to TeX-code in preamble "
1910
1911   if document.textclass != "moderncv":
1912     return
1913   i = 0
1914   j = 0
1915   lineArg = 0
1916   while True:
1917     # at first revert the new styles
1918     # \moderncvicons
1919     i = find_token(document.body, "\\begin_layout CVIcons", 0)
1920     if i == -1:
1921       return
1922     j = find_end_of_layout(document.body, i)
1923     if j == -1:
1924       document.warning("Malformed LyX document: Can't find end of CVIcons layout")
1925       i += 1
1926       continue
1927     content = lyx2latex(document, document.body[i:j + 1])
1928     add_to_preamble(document, ["\\moderncvicons{" + content + "}"])
1929     del document.body[i:j + 1]
1930     # \hintscolumnwidth
1931     i = find_token(document.body, "\\begin_layout CVColumnWidth", 0)
1932     if i == -1:
1933       return
1934     j = find_end_of_layout(document.body, i)
1935     if j == -1:
1936       document.warning("Malformed LyX document: Can't find end of CVColumnWidth layout")
1937       i += 1
1938       continue
1939     content = lyx2latex(document, document.body[i:j + 1])
1940     add_to_preamble(document, ["\\setlength{\hintscolumnwidth}{" + content + "}"])
1941     del document.body[i:j + 1]
1942     # now change the new styles to the obsolete ones
1943     # \name
1944     i = find_token(document.body, "\\begin_layout Name", 0)
1945     if i == -1:
1946       return
1947     j = find_end_of_layout(document.body, i)
1948     if j == -1:
1949       document.warning("Malformed LyX document: Can't find end of Name layout")
1950       i += 1
1951       continue
1952     lineArg = find_token(document.body, "\\begin_inset Argument 1", i)
1953     if lineArg > j and j != 0:
1954       return
1955     if lineArg != -1:
1956       beginPlain = find_token(document.body, "\\begin_layout Plain Layout", lineArg)
1957       # we have to assure that no other inset is in the Argument
1958       beginInset = find_token(document.body, "\\begin_inset", beginPlain)
1959       endInset = find_token(document.body, "\\end_inset", beginPlain)
1960       k = beginPlain + 1
1961       l = k
1962       while beginInset < endInset and beginInset != -1:
1963         beginInset = find_token(document.body, "\\begin_inset", k)
1964         endInset = find_token(document.body, "\\end_inset", l)
1965         k = beginInset + 1
1966         l = endInset + 1
1967       Arg2 = document.body[l + 5 : l + 6]
1968       # rename the style
1969       document.body[i : i + 1]= ["\\begin_layout FirstName"]
1970       # delete the Argument inset
1971       del( document.body[endInset - 2 : endInset + 3])
1972       del( document.body[lineArg : beginPlain + 1])
1973       document.body[i + 4 : i + 4]= ["\\begin_layout FamilyName"] + Arg2 + ["\\end_layout"] + [""]
1974
1975
1976 def revert_moderncv_2(document):
1977   " Reverts the phone inset of moderncv to the obsoleted mobile or fax "
1978
1979   if document.textclass != "moderncv":
1980     return
1981   i = 0
1982   j = 0
1983   lineArg = 0
1984   while True:
1985     # \phone
1986     i = find_token(document.body, "\\begin_layout Phone", i)
1987     if i == -1:
1988       return
1989     j = find_end_of_layout(document.body, i)
1990     if j == -1:
1991       document.warning("Malformed LyX document: Can't find end of Phone layout")
1992       i += 1
1993       return
1994     lineArg = find_token(document.body, "\\begin_inset Argument 1", i)
1995     if lineArg > j and j != 0:
1996       i += 1
1997       continue
1998     if lineArg != -1:
1999       beginPlain = find_token(document.body, "\\begin_layout Plain Layout", lineArg)
2000       # we have to assure that no other inset is in the Argument
2001       beginInset = find_token(document.body, "\\begin_inset", beginPlain)
2002       endInset = find_token(document.body, "\\end_inset", beginPlain)
2003       k = beginPlain + 1
2004       l = k
2005       while beginInset < endInset and beginInset != -1:
2006         beginInset = find_token(document.body, "\\begin_inset", k)
2007         endInset = find_token(document.body, "\\end_inset", l)
2008         k = beginInset + 1
2009         l = endInset + 1
2010       Arg = document.body[beginPlain + 1 : beginPlain + 2]
2011       # rename the style
2012       if Arg[0] == "mobile":
2013         document.body[i : i + 1]= ["\\begin_layout Mobile"]
2014       if Arg[0] == "fax":
2015         document.body[i : i + 1]= ["\\begin_layout Fax"]
2016       # delete the Argument inset
2017       del(document.body[endInset - 2 : endInset + 1])
2018       del(document.body[lineArg : beginPlain + 3])
2019     i += 1
2020
2021
2022 def convert_moderncv_phone(document):
2023     " Convert the Fax and Mobile inset of moderncv to the new phone inset "
2024
2025     if document.textclass != "moderncv":
2026         return
2027     i = 0
2028     j = 0
2029     lineArg = 0
2030
2031     phone_dict = {
2032         "Mobile" : "mobile",
2033         "Fax" : "fax",
2034         }
2035
2036     rx = re.compile(r'^\\begin_layout (\S+)$')
2037     while True:
2038         # substitute \fax and \mobile by \phone[fax] and \phone[mobile], respectively
2039         i = find_token(document.body, "\\begin_layout", i)
2040         if i == -1:
2041             return
2042
2043         m = rx.match(document.body[i])
2044         val = ""
2045         if m:
2046             val = m.group(1)
2047         if val not in list(phone_dict.keys()):
2048             i += 1
2049             continue
2050         j = find_end_of_layout(document.body, i)
2051         if j == -1:
2052             document.warning("Malformed LyX document: Can't find end of Mobile layout")
2053             i += 1
2054             return
2055
2056         document.body[i : i + 1] = ["\\begin_layout Phone", "\\begin_inset Argument 1", "status open", "",
2057                             "\\begin_layout Plain Layout", phone_dict[val], "\\end_layout", "",
2058                             "\\end_inset", ""]
2059
2060
2061 def convert_moderncv_name(document):
2062     " Convert the FirstName and LastName layout of moderncv to the general Name layout "
2063
2064     if document.textclass != "moderncv":
2065         return
2066
2067     fnb = 0 # Begin of FirstName inset
2068     fne = 0 # End of FirstName inset
2069     lnb = 0 # Begin of LastName (FamilyName) inset
2070     lne = 0 # End of LastName (FamilyName) inset
2071     nb = 0 # Begin of substituting Name inset
2072     ne = 0 # End of substituting Name inset
2073     FirstName = [] # FirstName content
2074     FamilyName = [] # LastName content
2075
2076     while True:
2077         # locate FirstName
2078         fnb = find_token(document.body, "\\begin_layout FirstName", fnb)
2079         if fnb != -1:
2080             fne = find_end_of_layout(document.body, fnb)
2081             if fne == -1:
2082                 document.warning("Malformed LyX document: Can't find end of FirstName layout")
2083                 return
2084             FirstName = document.body[fnb + 1 : fne]
2085         # locate FamilyName
2086         lnb = find_token(document.body, "\\begin_layout FamilyName", lnb)
2087         if lnb != -1:
2088             lne = find_end_of_layout(document.body, lnb)
2089             if lne == -1:
2090                 document.warning("Malformed LyX document: Can't find end of FamilyName layout")
2091                 return
2092             FamilyName = document.body[lnb + 1 : lne]
2093         # Determine the region for the substituting Name layout
2094         if fnb == -1 and lnb == -1: # Neither FirstName nor FamilyName exists -> Do nothing
2095             return
2096         elif fnb == -1: # Only FamilyName exists -> New Name insets replaces that
2097             nb = lnb
2098             ne = lne
2099         elif lnb == -1: # Only FirstName exists -> New Name insets replaces that
2100             nb = fnb
2101             ne = fne
2102         elif fne > lne: # FirstName position before FamilyName -> New Name insets spans
2103             nb = lnb #     from FamilyName begin
2104             ne = fne #     to FirstName end
2105         else: #           FirstName position before FamilyName -> New Name insets spans
2106             nb = fnb #     from FirstName begin
2107             ne = lne #     to FamilyName end
2108
2109         # Insert the substituting layout now. If FirstName exists, use an otpional argument.
2110         if FirstName == []:
2111             document.body[nb : ne + 1] = ["\\begin_layout Name"] + FamilyName + ["\\end_layout", ""]
2112         else:
2113             document.body[nb : ne + 1] = ["\\begin_layout Name", "\\begin_inset Argument 1", "status open", "",
2114                                 "\\begin_layout Plain Layout"] + FirstName + ["\\end_layout", "",
2115                                 "\\end_inset", ""] + FamilyName + ["\\end_layout", ""]
2116
2117
2118 def revert_achemso(document):
2119   " Reverts the flex inset Latin to TeX code "
2120
2121   if document.textclass != "achemso":
2122     return
2123   i = 0
2124   j = 0
2125   while True:
2126     i = find_token(document.body, "\\begin_inset Flex Latin", i)
2127     if i != -1:
2128       j = find_end_of_inset(document.body, i)
2129     else:
2130       return
2131     if j != -1:
2132       beginPlain = find_token(document.body, "\\begin_layout Plain Layout", i)
2133       endPlain = find_end_of_layout(document.body, beginPlain)
2134       content = lyx2latex(document, document.body[beginPlain : endPlain])
2135       document.body[i:j + 1] = put_cmd_in_ert("\\latin{" + content + "}")
2136     else:
2137       document.warning("Malformed LyX document: Can't find end of flex inset Latin")
2138       return
2139     i += 1
2140
2141
2142 fontsettings = ["\\font_roman", "\\font_sans", "\\font_typewriter", "\\font_math", \
2143                 "\\font_sf_scale", "\\font_tt_scale"]
2144 fontdefaults = ["default", "default", "default", "auto", "100", "100"]
2145 fontquotes = [True, True, True, True, False, False]
2146
2147 def convert_fontsettings(document):
2148     " Duplicate font settings "
2149
2150     i = find_token(document.header, "\\use_non_tex_fonts ", 0)
2151     if i == -1:
2152         document.warning("Malformed LyX document: No \\use_non_tex_fonts!")
2153         use_non_tex_fonts = "false"
2154     else:
2155         use_non_tex_fonts = get_value(document.header, "\\use_non_tex_fonts", i)
2156     j = 0
2157     for f in fontsettings:
2158         i = find_token(document.header, f + " ", 0)
2159         if i == -1:
2160             document.warning("Malformed LyX document: No " + f + "!")
2161             # we can fix that
2162             # note that with i = -1, this will insert at the end
2163             # of the header
2164             value = fontdefaults[j]
2165         else:
2166             value = document.header[i][len(f):].strip()
2167         if fontquotes[j]:
2168             if use_non_tex_fonts == "true":
2169                 document.header[i:i+1] = [f + ' "' + fontdefaults[j] + '" "' + value + '"']
2170             else:
2171                 document.header[i:i+1] = [f + ' "' + value + '" "' + fontdefaults[j] + '"']
2172         else:
2173             if use_non_tex_fonts == "true":
2174                 document.header[i:i+1] = [f + ' ' + fontdefaults[j] + ' ' + value]
2175             else:
2176                 document.header[i:i+1] = [f + ' ' + value + ' ' + fontdefaults[j]]
2177         j = j + 1
2178
2179
2180 def revert_fontsettings(document):
2181     " Merge font settings "
2182
2183     i = find_token(document.header, "\\use_non_tex_fonts ", 0)
2184     if i == -1:
2185         document.warning("Malformed LyX document: No \\use_non_tex_fonts!")
2186         use_non_tex_fonts = "false"
2187     else:
2188         use_non_tex_fonts = get_value(document.header, "\\use_non_tex_fonts", i)
2189     j = 0
2190     for f in fontsettings:
2191         i = find_token(document.header, f + " ", 0)
2192         if i == -1:
2193             document.warning("Malformed LyX document: No " + f + "!")
2194             j = j + 1
2195             continue
2196         line = get_value(document.header, f, i)
2197         if fontquotes[j]:
2198             q1 = line.find('"')
2199             q2 = line.find('"', q1+1)
2200             q3 = line.find('"', q2+1)
2201             q4 = line.find('"', q3+1)
2202             if q1 == -1 or q2 == -1 or q3 == -1 or q4 == -1:
2203                 document.warning("Malformed LyX document: Missing quotes!")
2204                 j = j + 1
2205                 continue
2206             if use_non_tex_fonts == "true":
2207                 document.header[i:i+1] = [f + ' ' + line[q3+1:q4]]
2208             else:
2209                 document.header[i:i+1] = [f + ' ' + line[q1+1:q2]]
2210         else:
2211             if use_non_tex_fonts == "true":
2212                 document.header[i:i+1] = [f + ' ' + line.split()[1]]
2213             else:
2214                 document.header[i:i+1] = [f + ' ' + line.split()[0]]
2215         j = j + 1
2216
2217
2218 def revert_solution(document):
2219     " Reverts the solution environment of the theorem module to TeX code "
2220
2221     # Do we use one of the modules that provides Solution?
2222     have_mod = False
2223     mods = document.get_module_list()
2224     for mod in mods:
2225         if mod == "theorems-std" or mod == "theorems-bytype" \
2226         or mod == "theorems-ams" or mod == "theorems-ams-bytype":
2227             have_mod = True
2228             break
2229     if not have_mod:
2230         return
2231
2232     consecutive = False
2233     is_starred = False
2234     i = 0
2235     while True:
2236         i = find_token(document.body, "\\begin_layout Solution", i)
2237         if i == -1:
2238             return
2239
2240         is_starred = document.body[i].startswith("\\begin_layout Solution*")
2241         if is_starred == True:
2242             LaTeXName = "sol*"
2243             LyXName = "Solution*"
2244             theoremName = "newtheorem*"
2245         else:
2246             LaTeXName = "sol"
2247             LyXName = "Solution"
2248             theoremName = "newtheorem"
2249
2250         j = find_end_of_layout(document.body, i)
2251         if j == -1:
2252             document.warning("Malformed LyX document: Can't find end of " + LyXName + " layout")
2253             i += 1
2254             continue
2255
2256         # if this is not a consecutive env, add start command
2257         begcmd = []
2258         if not consecutive:
2259             begcmd = put_cmd_in_ert("\\begin{%s}" % (LaTeXName))
2260
2261         # has this a consecutive theorem of same type?
2262         consecutive = document.body[j + 2] == "\\begin_layout " + LyXName
2263
2264         # if this is not followed by a consecutive env, add end command
2265         if not consecutive:
2266             document.body[j : j + 1] = put_cmd_in_ert("\\end{%s}" % (LaTeXName)) + ["\\end_layout"]
2267
2268         document.body[i : i + 1] = ["\\begin_layout Standard", ""] + begcmd
2269
2270         add_to_preamble(document, "\\theoremstyle{definition}")
2271         if is_starred or mod == "theorems-bytype" or mod == "theorems-ams-bytype":
2272             add_to_preamble(document, "\\%s{%s}{\\protect\\solutionname}" % \
2273                 (theoremName, LaTeXName))
2274         else: # mod == "theorems-std" or mod == "theorems-ams" and not is_starred
2275             add_to_preamble(document, "\\%s{%s}[thm]{\\protect\\solutionname}" % \
2276                 (theoremName, LaTeXName))
2277
2278         add_to_preamble(document, "\\providecommand{\solutionname}{Solution}")
2279         i = j
2280
2281
2282 def revert_verbatim_star(document):
2283     from lyx_2_1 import revert_verbatim
2284     revert_verbatim(document, True)
2285
2286
2287 def convert_save_props(document):
2288     " Add save_transient_properties parameter. "
2289     i = find_token(document.header, '\\begin_header', 0)
2290     if i == -1:
2291         document.warning("Malformed lyx document: Missing '\\begin_header'.")
2292         return
2293     document.header.insert(i + 1, '\\save_transient_properties true')
2294
2295
2296 def revert_save_props(document):
2297     " Remove save_transient_properties parameter. "
2298     i = find_token(document.header, "\\save_transient_properties", 0)
2299     if i == -1:
2300         return
2301     del document.header[i]
2302
2303
2304 def convert_info_tabular_feature(document):
2305     def f(arg):
2306         return arg.replace("inset-modify tabular", "tabular-feature")
2307     convert_info_insets(document, "shortcut(s)?|icon", f)
2308
2309
2310 def revert_info_tabular_feature(document):
2311     def f(arg):
2312         return arg.replace("tabular-feature", "inset-modify tabular")
2313     convert_info_insets(document, "shortcut(s)?|icon", f)
2314
2315
2316 ##
2317 # Conversion hub
2318 #
2319
2320 supported_versions = ["2.2.0", "2.2"]
2321 convert = [
2322            [475, [convert_separator]],
2323            # nothing to do for 476: We consider it a bug that older versions
2324            # did not load amsmath automatically for these commands, and do not
2325            # want to hardcode amsmath off.
2326            [476, []],
2327            [477, []],
2328            [478, []],
2329            [479, []],
2330            [480, []],
2331            [481, [convert_dashes]],
2332            [482, [convert_phrases]],
2333            [483, [convert_specialchar]],
2334            [484, []],
2335            [485, []],
2336            [486, []],
2337            [487, []],
2338            [488, [convert_newgloss]],
2339            [489, [convert_BoxFeatures]],
2340            [490, [convert_origin]],
2341            [491, []],
2342            [492, [convert_colorbox]],
2343            [493, []],
2344            [494, []],
2345            [495, [convert_subref]],
2346            [496, [convert_nounzip]],
2347            [497, [convert_external_bbox]],
2348            [498, []],
2349            [499, [convert_moderncv_phone, convert_moderncv_name]],
2350            [500, []],
2351            [501, [convert_fontsettings]],
2352            [502, []],
2353            [503, []],
2354            [504, [convert_save_props]],
2355            [505, []],
2356            [506, [convert_info_tabular_feature]],
2357            [507, [convert_longtable_label]],
2358            [508, [convert_parbreak]]
2359           ]
2360
2361 revert =  [
2362            [507, [revert_parbreak]],
2363            [506, [revert_longtable_label]],
2364            [505, [revert_info_tabular_feature]],
2365            [504, []],
2366            [503, [revert_save_props]],
2367            [502, [revert_verbatim_star]],
2368            [501, [revert_solution]],
2369            [500, [revert_fontsettings]],
2370            [499, [revert_achemso]],
2371            [498, [revert_moderncv_1, revert_moderncv_2]],
2372            [497, [revert_tcolorbox_1, revert_tcolorbox_2,
2373                   revert_tcolorbox_3, revert_tcolorbox_4, revert_tcolorbox_5,
2374                   revert_tcolorbox_6, revert_tcolorbox_7, revert_tcolorbox_8]],
2375            [496, [revert_external_bbox]],
2376            [495, []], # nothing to do since the noUnzip parameter was optional
2377            [494, [revert_subref]],
2378            [493, [revert_jss]],
2379            [492, [revert_mathmulticol]],
2380            [491, [revert_colorbox]],
2381            [490, [revert_textcolor]],
2382            [489, [revert_origin]],
2383            [488, [revert_BoxFeatures]],
2384            [487, [revert_newgloss, revert_glossgroup]],
2385            [486, [revert_forest]],
2386            [485, [revert_ex_itemargs]],
2387            [484, [revert_sigplan_doi]],
2388            [483, [revert_georgian]],
2389            [482, [revert_specialchar]],
2390            [481, [revert_phrases]],
2391            [480, [revert_dashes]],
2392            [479, [revert_question_env]],
2393            [478, [revert_beamer_lemma]],
2394            [477, [revert_xarrow]],
2395            [476, [revert_swissgerman]],
2396            [475, [revert_smash]],
2397            [474, [revert_separator]]
2398           ]
2399
2400
2401 if __name__ == "__main__":
2402     pass