lib/lyx2lyx/lyx_2_1.py

   1 # -*- coding: utf-8 -*-
   2 # This file is part of lyx2lyx
   3 # -*- coding: utf-8 -*-
   4 # Copyright (C) 2011 The LyX team
   5 #
   6 # This program is free software; you can redistribute it and/or
   7 # modify it under the terms of the GNU General Public License
   8 # as published by the Free Software Foundation; either version 2
   9 # of the License, or (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 # GNU General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program; if not, write to the Free Software
  18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  19
  20 """ Convert files to the file format generated by lyx 2.1"""
  21
  22 import re, string
  23 import unicodedata
  24 import sys, os
  25
  26 # Uncomment only what you need to import, please.
  27
  28 from parser_tools import del_token, find_token, find_end_of, find_end_of_inset, \
  29     find_end_of_layout, find_re, get_option_value, get_value, get_quoted_value, \
  30     set_option_value
  31
  32 #from parser_tools import find_token, find_end_of, find_tokens, \
  33   #find_token_exact, find_end_of_inset, find_end_of_layout, \
  34   #find_token_backwards, is_in_inset, del_token, check_token
  35
  36 from lyx2lyx_tools import add_to_preamble, put_cmd_in_ert, get_ert
  37
  38 #from lyx2lyx_tools import insert_to_preamble, \
  39 #  lyx2latex, latex_length, revert_flex_inset, \
  40 #  revert_font_attrs, hex2ratio, str2bool
  41
  42 ####################################################################
  43 # Private helper functions
  44
  45 #def remove_option(lines, m, option):
  46     #''' removes option from line m. returns whether we did anything '''
  47     #l = lines[m].find(option)
  48     #if l == -1:
  49         #return False
  50     #val = lines[m][l:].split('"')[1]
  51     #lines[m] = lines[m][:l - 1] + lines[m][l+len(option + '="' + val + '"'):]
  52     #return True
  53
  54
  55 ###############################################################################
  56 ###
  57 ### Conversion and reversion routines
  58 ###
  59 ###############################################################################
  60
  61 def revert_visible_space(document):
  62     "Revert InsetSpace visible into its ERT counterpart"
  63     i = 0
  64     while True:
  65       i = find_token(document.body, "\\begin_inset space \\textvisiblespace{}", i)
  66       if i == -1:
  67         return
  68       end = find_end_of_inset(document.body, i)
  69       subst = put_cmd_in_ert("\\textvisiblespace{}")
  70       document.body[i:end + 1] = subst
  71
  72
  73 def convert_undertilde(document):
  74     " Load undertilde automatically "
  75     i = find_token(document.header, "\\use_mathdots" , 0)
  76     if i == -1:
  77         i = find_token(document.header, "\\use_mhchem" , 0)
  78     if i == -1:
  79         i = find_token(document.header, "\\use_esint" , 0)
  80     if i == -1:
  81         document.warning("Malformed LyX document: Can't find \\use_mathdots.")
  82         return;
  83     j = find_token(document.preamble, "\\usepackage{undertilde}", 0)
  84     if j == -1:
  85         document.header.insert(i + 1, "\\use_undertilde 0")
  86     else:
  87         document.header.insert(i + 1, "\\use_undertilde 2")
  88         del document.preamble[j]
  89
  90
  91 def revert_undertilde(document):
  92     " Load undertilde if used in the document "
  93     undertilde = find_token(document.header, "\\use_undertilde" , 0)
  94     if undertilde == -1:
  95       document.warning("No \\use_undertilde line. Assuming auto.")
  96     else:
  97       val = get_value(document.header, "\\use_undertilde", undertilde)
  98       del document.header[undertilde]
  99       try:
 100         usetilde = int(val)
 101       except:
 102         document.warning("Invalid \\use_undertilde value: " + val + ". Assuming auto.")
 103         # probably usedots has not been changed, but be safe.
 104         usetilde = 1
 105
 106       if usetilde == 0:
 107         # do not load case
 108         return
 109       if usetilde == 2:
 110         # force load case
 111         add_to_preamble(document, ["\\usepackage{undertilde}"])
 112         return
 113
 114     # so we are in the auto case. we want to load undertilde if \utilde is used.
 115     i = 0
 116     while True:
 117       i = find_token(document.body, '\\begin_inset Formula', i)
 118       if i == -1:
 119         return
 120       j = find_end_of_inset(document.body, i)
 121       if j == -1:
 122         document.warning("Malformed LyX document: Can't find end of Formula inset at line " + str(i))
 123         i += 1
 124         continue
 125       code = "\n".join(document.body[i:j])
 126       if code.find("\\utilde") != -1:
 127         add_to_preamble(document, ["\\@ifundefined{utilde}{\\usepackage{undertilde}}"])
 128         return
 129       i = j
 130
 131
 132 def revert_negative_space(document):
 133     "Revert InsetSpace negmedspace and negthickspace into its TeX-code counterpart"
 134     i = 0
 135     j = 0
 136     reverted = False
 137     while True:
 138       i = find_token(document.body, "\\begin_inset space \\negmedspace{}", i)
 139       if i == -1:
 140         j = find_token(document.body, "\\begin_inset space \\negthickspace{}", j)
 141         if j == -1:
 142           # load amsmath in the preamble if not already loaded if we are at the end of checking
 143           if reverted == True:
 144             i = find_token(document.header, "\\use_amsmath 2", 0)
 145             if i == -1:
 146               add_to_preamble(document, ["\\@ifundefined{negthickspace}{\\usepackage{amsmath}}"])
 147           return
 148       if i == -1:
 149         return
 150       end = find_end_of_inset(document.body, i)
 151       subst = put_cmd_in_ert("\\negmedspace{}")
 152       document.body[i:end + 1] = subst
 153       j = find_token(document.body, "\\begin_inset space \\negthickspace{}", j)
 154       if j == -1:
 155         return
 156       end = find_end_of_inset(document.body, j)
 157       subst = put_cmd_in_ert("\\negthickspace{}")
 158       document.body[j:end + 1] = subst
 159       reverted = True
 160
 161
 162 def revert_math_spaces(document):
 163     "Revert formulas with protected custom space and protected hfills to TeX-code"
 164     i = 0
 165     while True:
 166       i = find_token(document.body, "\\begin_inset Formula", i)
 167       if i == -1:
 168         return
 169       j = document.body[i].find("\\hspace*")
 170       if j != -1:
 171         end = find_end_of_inset(document.body, i)
 172         subst = put_cmd_in_ert(document.body[i][21:])
 173         document.body[i:end + 1] = subst
 174       i = i + 1
 175
 176
 177 def convert_japanese_encodings(document):
 178     " Rename the japanese encodings to names understood by platex "
 179     jap_enc_dict = {
 180         "EUC-JP-pLaTeX": "euc",
 181         "JIS-pLaTeX":    "jis",
 182         "SJIS-pLaTeX":   "sjis"
 183     }
 184     i = find_token(document.header, "\\inputencoding" , 0)
 185     if i == -1:
 186         return
 187     val = get_value(document.header, "\\inputencoding", i)
 188     if val in jap_enc_dict.keys():
 189         document.header[i] = "\\inputencoding %s" % jap_enc_dict[val]
 190
 191
 192 def revert_japanese_encodings(document):
 193     " Revert the japanese encodings name changes "
 194     jap_enc_dict = {
 195         "euc":  "EUC-JP-pLaTeX",
 196         "jis":  "JIS-pLaTeX",
 197         "sjis": "SJIS-pLaTeX"
 198     }
 199     i = find_token(document.header, "\\inputencoding" , 0)
 200     if i == -1:
 201         return
 202     val = get_value(document.header, "\\inputencoding", i)
 203     if val in jap_enc_dict.keys():
 204         document.header[i] = "\\inputencoding %s" % jap_enc_dict[val]
 205
 206
 207 def revert_justification(document):
 208     " Revert the \\justification buffer param"
 209     if not del_token(document.header, '\\justification', 0):
 210         document.warning("Malformed LyX document: Missing \\justification.")
 211
 212
 213 def revert_australian(document):
 214     "Set English language variants Australian and Newzealand to English"
 215
 216     if document.language == "australian" or document.language == "newzealand":
 217         document.language = "english"
 218         i = find_token(document.header, "\\language", 0)
 219         if i != -1:
 220             document.header[i] = "\\language english"
 221
 222     j = 0
 223     while True:
 224         j = find_token(document.body, "\\lang australian", j)
 225         if j == -1:
 226             j = find_token(document.body, "\\lang newzealand", 0)
 227             if j == -1:
 228                 return
 229             else:
 230                 document.body[j] = document.body[j].replace("\\lang newzealand", "\\lang english")
 231         else:
 232             document.body[j] = document.body[j].replace("\\lang australian", "\\lang english")
 233         j += 1
 234
 235
 236 def convert_biblio_style(document):
 237     "Add a sensible default for \\biblio_style based on the citation engine."
 238     i = find_token(document.header, "\\cite_engine", 0)
 239     if i != -1:
 240         engine = get_value(document.header, "\\cite_engine", i).split("_")[0]
 241         style = {"basic": "plain", "natbib": "plainnat", "jurabib": "jurabib"}
 242         document.header.insert(i + 1, "\\biblio_style " + style[engine])
 243
 244
 245 def revert_biblio_style(document):
 246     "BibTeX insets with default option use the style defined by \\biblio_style."
 247     i = find_token(document.header, "\\biblio_style" , 0)
 248     if i == -1:
 249         document.warning("No \\biblio_style line. Nothing to do.")
 250         return
 251
 252     default_style = get_value(document.header, "\\biblio_style", i)
 253     del document.header[i]
 254
 255     # We are looking for bibtex insets having the default option
 256     i = 0
 257     while True:
 258         i = find_token(document.body, "\\begin_inset CommandInset bibtex", i)
 259         if i == -1:
 260             return
 261         j = find_end_of_inset(document.body, i)
 262         if j == -1:
 263             document.warning("Malformed LyX document: Can't find end of bibtex inset at line " + str(i))
 264             i += 1
 265             return
 266         k = find_token(document.body, "options", i, j)
 267         if k != -1:
 268             options = get_quoted_value(document.body, "options", k)
 269             if "default" in options.split(","):
 270                 document.body[k] = 'options "%s"' \
 271                     % options.replace("default", default_style)
 272         i = j
 273
 274
 275 def handle_longtable_captions(document, forward):
 276     begin_table = 0
 277     while True:
 278         begin_table = find_token(document.body, '<lyxtabular version=', begin_table)
 279         if begin_table == -1:
 280             break
 281         end_table = find_end_of(document.body, begin_table, '<lyxtabular', '</lyxtabular>')
 282         if end_table == -1:
 283             document.warning("Malformed LyX document: Could not find end of table.")
 284             begin_table += 1
 285             continue
 286         fline = find_token(document.body, "<features", begin_table, end_table)
 287         if fline == -1:
 288             document.warning("Can't find features for inset at line " + str(begin_table))
 289             begin_table += 1
 290             continue
 291         p = document.body[fline].find("islongtable")
 292         if p == -1:
 293             # no longtable
 294             begin_table += 1
 295             continue
 296         numrows = get_option_value(document.body[begin_table], "rows")
 297         try:
 298             numrows = int(numrows)
 299         except:
 300             document.warning(document.body[begin_table])
 301             document.warning("Unable to determine rows!")
 302             begin_table = end_table
 303             continue
 304         begin_row = begin_table
 305         for row in range(numrows):
 306             begin_row = find_token(document.body, '<row', begin_row, end_table)
 307             if begin_row == -1:
 308                 document.warning("Can't find row " + str(row + 1))
 309                 break
 310             end_row = find_end_of(document.body, begin_row, '<row', '</row>')
 311             if end_row == -1:
 312                 document.warning("Can't find end of row " + str(row + 1))
 313                 break
 314             if forward:
 315                 if (get_option_value(document.body[begin_row], 'caption') == 'true' and
 316                     get_option_value(document.body[begin_row], 'endfirsthead') != 'true' and
 317                     get_option_value(document.body[begin_row], 'endhead') != 'true' and
 318                     get_option_value(document.body[begin_row], 'endfoot') != 'true' and
 319                     get_option_value(document.body[begin_row], 'endlastfoot') != 'true'):
 320                     document.body[begin_row] = set_option_value(document.body[begin_row], 'caption', 'true", endfirsthead="true')
 321             elif get_option_value(document.body[begin_row], 'caption') == 'true':
 322                 if get_option_value(document.body[begin_row], 'endfirsthead') == 'true':
 323                     document.body[begin_row] = set_option_value(document.body[begin_row], 'endfirsthead', 'false')
 324                 if get_option_value(document.body[begin_row], 'endhead') == 'true':
 325                     document.body[begin_row] = set_option_value(document.body[begin_row], 'endhead', 'false')
 326                 if get_option_value(document.body[begin_row], 'endfoot') == 'true':
 327                     document.body[begin_row] = set_option_value(document.body[begin_row], 'endfoot', 'false')
 328                 if get_option_value(document.body[begin_row], 'endlastfoot') == 'true':
 329                     document.body[begin_row] = set_option_value(document.body[begin_row], 'endlastfoot', 'false')
 330             begin_row = end_row
 331         # since there could be a tabular inside this one, we
 332         # cannot jump to end.
 333         begin_table += 1
 334
 335
 336 def convert_longtable_captions(document):
 337     "Add a firsthead flag to caption rows"
 338     handle_longtable_captions(document, True)
 339
 340
 341 def revert_longtable_captions(document):
 342     "remove head/foot flag from caption rows"
 343     handle_longtable_captions(document, False)
 344
 345
 346 def convert_use_packages(document):
 347     "use_xxx yyy => use_package xxx yyy"
 348     packages = ["amsmath", "esint", "mathdots", "mhchem", "undertilde"]
 349     for p in packages:
 350         i = find_token(document.header, "\\use_%s" % p , 0)
 351         if i != -1:
 352             value = get_value(document.header, "\\use_%s" % p , i)
 353             document.header[i] = "\\use_package %s %s" % (p, value)
 354
 355
 356 def revert_use_packages(document):
 357     "use_package xxx yyy => use_xxx yyy"
 358     packages = {"amsmath":"1", "esint":"1", "mathdots":"1", "mhchem":"1", "undertilde":"1"}
 359     # the order is arbitrary for the use_package version, and not all packages need to be given.
 360     # Ensure a complete list and correct order (important for older LyX versions and especially lyx2lyx)
 361     j = -1
 362     for p in packages.keys():
 363         regexp = re.compile(r'(\\use_package\s+%s)' % p)
 364         i = find_re(document.header, regexp, 0)
 365         if i != -1:
 366             value = get_value(document.header, "\\use_package" , i).split()[1]
 367             del document.header[i]
 368             j = i
 369     for (p, v) in packages.items():
 370         document.header.insert(j, "\\use_%s %s"  % (p, value))
 371         j = j + 1
 372
 373
 374 def convert_use_mathtools(document):
 375     "insert use_package mathtools"
 376     i = find_token(document.header, "\\use_package", 0)
 377     if i == -1:
 378         document.warning("Malformed LyX document: Can't find \\use_package.")
 379         return;
 380     j = find_token(document.preamble, "\\usepackage{mathtools}", 0)
 381     if j == -1:
 382         document.header.insert(i + 1, "\\use_package mathtools 0")
 383     else:
 384         document.header.insert(i + 1, "\\use_package mathtools 2")
 385         del document.preamble[j]
 386
 387
 388 def revert_use_mathtools(document):
 389     "remove use_package mathtools"
 390     regexp = re.compile(r'(\\use_package\s+mathtools)')
 391     i = find_re(document.header, regexp, 0)
 392     value = "1" # default is auto
 393     if i != -1:
 394         value = get_value(document.header, "\\use_package" , i).split()[1]
 395         del document.header[i]
 396     if value == "2": # on
 397         add_to_preamble(document, ["\\usepackage{mathtools}"])
 398     elif value == "1": # auto
 399         commands = ["mathclap", "mathllap", "mathrlap", \
 400                     "lgathered", "rgathered", "vcentcolon", "dblcolon", \
 401                     "coloneqq", "Coloneqq", "coloneq", "Coloneq", "eqqcolon", \
 402                     "Eqqcolon", "eqcolon", "Eqcolon", "colonapprox", \
 403                     "Colonapprox", "colonsim", "Colonsim"]
 404         i = 0
 405         while True:
 406             i = find_token(document.body, '\\begin_inset Formula', i)
 407             if i == -1:
 408                 return
 409             j = find_end_of_inset(document.body, i)
 410             if j == -1:
 411                 document.warning("Malformed LyX document: Can't find end of Formula inset at line " + str(i))
 412                 i += 1
 413                 continue
 414             code = "\n".join(document.body[i:j])
 415             for c in commands:
 416                 if code.find("\\%s" % c) != -1:
 417                     add_to_preamble(document, ["\\usepackage{mathtools}"])
 418                     return
 419             i = j
 420
 421
 422 def convert_cite_engine_type(document):
 423     "Determine the \\cite_engine_type from the citation engine."
 424     i = find_token(document.header, "\\cite_engine", 0)
 425     if i == -1:
 426         return
 427     engine = get_value(document.header, "\\cite_engine", i)
 428     if "_" in engine:
 429         engine, type = engine.split("_")
 430     else:
 431         type = {"basic": "numerical", "jurabib": "authoryear"}[engine]
 432     document.header[i] = "\\cite_engine " + engine
 433     document.header.insert(i + 1, "\\cite_engine_type " + type)
 434
 435
 436 def revert_cite_engine_type(document):
 437     "Natbib had the type appended with an underscore."
 438     engine_type = "numerical"
 439     i = find_token(document.header, "\\cite_engine_type" , 0)
 440     if i == -1:
 441         document.warning("No \\cite_engine_type line. Assuming numerical.")
 442     else:
 443         engine_type = get_value(document.header, "\\cite_engine_type", i)
 444         del document.header[i]
 445
 446     # We are looking for the natbib citation engine
 447     i = find_token(document.header, "\\cite_engine natbib", 0)
 448     if i == -1:
 449         return
 450     document.header[i] = "\\cite_engine natbib_" + engine_type
 451
 452
 453 def revert_cancel(document):
 454     "add cancel to the preamble if necessary"
 455     commands = ["cancelto", "cancel", "bcancel", "xcancel"]
 456     i = 0
 457     while True:
 458         i = find_token(document.body, '\\begin_inset Formula', i)
 459         if i == -1:
 460             return
 461         j = find_end_of_inset(document.body, i)
 462         if j == -1:
 463             document.warning("Malformed LyX document: Can't find end of Formula inset at line " + str(i))
 464             i += 1
 465             continue
 466         code = "\n".join(document.body[i:j])
 467         for c in commands:
 468             if code.find("\\%s" % c) != -1:
 469                 add_to_preamble(document, ["\\usepackage{cancel}"])
 470                 return
 471         i = j
 472
 473
 474 def revert_verbatim(document):
 475     " Revert verbatim einvironments completely to TeX-code. "
 476     i = 0
 477     consecutive = False
 478     subst_end = ['\end_layout', '', '\\begin_layout Plain Layout',
 479                  '\end_layout', '',
 480                  '\\begin_layout Plain Layout', '', '',
 481                  '\\backslash', '',
 482                  'end{verbatim}',
 483                  '\\end_layout', '', '\\end_inset',
 484                  '', '', '\\end_layout']
 485     subst_begin = ['\\begin_layout Standard', '\\noindent',
 486                    '\\begin_inset ERT', 'status collapsed', '',
 487                    '\\begin_layout Plain Layout', '', '', '\\backslash',
 488                    'begin{verbatim}',
 489                    '\\end_layout', '', '\\begin_layout Plain Layout', '']
 490     while 1:
 491         i = find_token(document.body, "\\begin_layout Verbatim", i)
 492         if i == -1:
 493             return
 494         j = find_end_of_layout(document.body, i)
 495         if j == -1:
 496             document.warning("Malformed lyx document: Can't find end of Verbatim layout")
 497             i += 1
 498             continue
 499         # delete all line breaks insets (there are no other insets)
 500         l = i
 501         while 1:
 502             n = find_token(document.body, "\\begin_inset Newline newline", l)
 503             if n == -1:
 504                 n = find_token(document.body, "\\begin_inset Newline linebreak", l)
 505                 if n == -1:
 506                     break
 507             m = find_end_of_inset(document.body, n)
 508             del(document.body[m:m+1])
 509             document.body[n:n+1] = ['\end_layout', '', '\\begin_layout Plain Layout']
 510             l += 1
 511             j += 1
 512         # consecutive verbatim environments need to be connected
 513         k = find_token(document.body, "\\begin_layout Verbatim", j)
 514         if k == j + 2 and consecutive == False:
 515             consecutive = True
 516             document.body[j:j+1] = ['\end_layout', '', '\\begin_layout Plain Layout']
 517             document.body[i:i+1] = subst_begin
 518             continue
 519         if k == j + 2 and consecutive == True:
 520             document.body[j:j+1] = ['\end_layout', '', '\\begin_layout Plain Layout']
 521             del(document.body[i:i+1])
 522             continue
 523         if k != j + 2 and consecutive == True:
 524             document.body[j:j+1] = subst_end
 525             # the next paragraph must not be indented
 526             document.body[j+19:j+19] = ['\\noindent']
 527             del(document.body[i:i+1])
 528             consecutive = False
 529             continue
 530         else:
 531             document.body[j:j+1] = subst_end
 532             # the next paragraph must not be indented
 533             document.body[j+19:j+19] = ['\\noindent']
 534             document.body[i:i+1] = subst_begin
 535
 536
 537 def revert_tipa(document):
 538     " Revert native TIPA insets to mathed or ERT. "
 539     i = 0
 540     while 1:
 541         i = find_token(document.body, "\\begin_inset IPA", i)
 542         if i == -1:
 543             return
 544         j = find_end_of_inset(document.body, i)
 545         if j == -1:
 546             document.warning("Malformed lyx document: Can't find end of IPA inset")
 547             i += 1
 548             continue
 549         Multipar = False
 550         n = find_token(document.body, "\\begin_layout", i, j)
 551         if n == -1:
 552             document.warning("Malformed lyx document: IPA inset has no embedded layout")
 553             i += 1
 554             continue
 555         m = find_end_of_layout(document.body, n)
 556         if m == -1:
 557             document.warning("Malformed lyx document: Can't find end of embedded layout")
 558             i += 1
 559             continue
 560         content = document.body[n+1:m]
 561         p = find_token(document.body, "\\begin_layout", m, j)
 562         if p != -1 or len(content) > 1:
 563             Multipar = True
 564             content = document.body[i+1:j]
 565         if Multipar:
 566             # IPA insets with multiple pars need to be wrapped by \begin{IPA}...\end{IPA}
 567             document.body[i:j+1] = ['\\end_layout', '', '\\begin_layout Standard'] + put_cmd_in_ert("\\begin{IPA}") + ['\\end_layout'] + content + ['\\begin_layout Standard'] + put_cmd_in_ert("\\end{IPA}")
 568             add_to_preamble(document, ["\\usepackage{tipa,tipx}"])
 569         else:
 570             # single-par IPA insets can be reverted to mathed
 571             document.body[i:j+1] = ["\\begin_inset Formula $\\text{\\textipa{" + content[0] + "}}$", "\\end_inset"]
 572         i = j
 573
 574
 575 def revert_cell_rotation(document):
 576   "Revert cell rotations to TeX-code"
 577
 578   load_rotating = False
 579   i = 0
 580   try:
 581     while True:
 582       # first, let's find out if we need to do anything
 583       i = find_token(document.body, '<cell ', i)
 584       if i == -1:
 585         return
 586       j = document.body[i].find('rotate="')
 587       if j != -1:
 588         k = document.body[i].find('"', j + 8)
 589         value = document.body[i][j + 8 : k]
 590         if value == "0":
 591           rgx = re.compile(r' rotate="[^"]+?"')
 592           # remove rotate option
 593           document.body[i] = rgx.sub('', document.body[i])
 594         elif value == "90":
 595           rgx = re.compile(r' rotate="[^"]+?"')
 596           document.body[i] = rgx.sub('rotate="true"', document.body[i])
 597         else:
 598           rgx = re.compile(r' rotate="[^"]+?"')
 599           load_rotating = True
 600           # remove rotate option
 601           document.body[i] = rgx.sub('', document.body[i])
 602           # write ERT
 603           document.body[i + 5 : i + 5] = \
 604             put_cmd_in_ert("\\end{turn}")
 605           document.body[i + 4 : i + 4] = \
 606             put_cmd_in_ert("\\begin{turn}{" + value + "}")
 607
 608       i += 1
 609
 610   finally:
 611     if load_rotating:
 612       add_to_preamble(document, ["\\@ifundefined{turnbox}{\usepackage{rotating}}{}"])
 613
 614
 615 def convert_cell_rotation(document):
 616     'Convert cell rotation statements from "true" to "90"'
 617
 618     i = 0
 619     while True:
 620       # first, let's find out if we need to do anything
 621       i = find_token(document.body, '<cell ', i)
 622       if i == -1:
 623         return
 624       j = document.body[i].find('rotate="true"')
 625       if j != -1:
 626         rgx = re.compile(r'rotate="[^"]+?"')
 627         # convert "true" to "90"
 628         document.body[i] = rgx.sub('rotate="90"', document.body[i])
 629
 630       i += 1
 631
 632
 633 def revert_table_rotation(document):
 634   "Revert table rotations to TeX-code"
 635
 636   load_rotating = False
 637   i = 0
 638   try:
 639     while True:
 640       # first, let's find out if we need to do anything
 641       i = find_token(document.body, '<features ', i)
 642       if i == -1:
 643         return
 644       j = document.body[i].find('rotate="')
 645       if j != -1:
 646         end_table = find_token(document.body, '</lyxtabular>', j)
 647         k = document.body[i].find('"', j + 8)
 648         value = document.body[i][j + 8 : k]
 649         if value == "0":
 650           rgx = re.compile(r' rotate="[^"]+?"')
 651           # remove rotate option
 652           document.body[i] = rgx.sub('', document.body[i])
 653         elif value == "90":
 654           rgx = re.compile(r'rotate="[^"]+?"')
 655           document.body[i] = rgx.sub('rotate="true"', document.body[i])
 656         else:
 657           rgx = re.compile(r' rotate="[^"]+?"')
 658           load_rotating = True
 659           # remove rotate option
 660           document.body[i] = rgx.sub('', document.body[i])
 661           # write ERT
 662           document.body[end_table + 3 : end_table + 3] = \
 663             put_cmd_in_ert("\\end{turn}")
 664           document.body[i - 2 : i - 2] = \
 665             put_cmd_in_ert("\\begin{turn}{" + value + "}")
 666
 667       i += 1
 668
 669   finally:
 670     if load_rotating:
 671       add_to_preamble(document, ["\\@ifundefined{turnbox}{\usepackage{rotating}}{}"])
 672
 673
 674 def convert_table_rotation(document):
 675     'Convert table rotation statements from "true" to "90"'
 676
 677     i = 0
 678     while True:
 679       # first, let's find out if we need to do anything
 680       i = find_token(document.body, '<features ', i)
 681       if i == -1:
 682         return
 683       j = document.body[i].find('rotate="true"')
 684       if j != -1:
 685         rgx = re.compile(r'rotate="[^"]+?"')
 686         # convert "true" to "90"
 687         document.body[i] = rgx.sub('rotate="90"', document.body[i])
 688
 689       i += 1
 690
 691
 692 def convert_listoflistings(document):
 693     'Convert ERT \lstlistoflistings to TOC lstlistoflistings inset'
 694     # We can support roundtrip because the command is so simple
 695     i = 0
 696     while True:
 697         i = find_token(document.body, "\\begin_inset ERT", i)
 698         if i == -1:
 699             return
 700         j = find_end_of_inset(document.body, i)
 701         if j == -1:
 702             document.warning("Malformed lyx document: Can't find end of ERT inset")
 703             i += 1
 704             continue
 705         ert = get_ert(document.body, i)
 706         if ert == "\\lstlistoflistings{}":
 707             document.body[i:j] = ["\\begin_inset CommandInset toc", "LatexCommand lstlistoflistings", ""]
 708             i = i + 4
 709         else:
 710             i = j + 1
 711
 712
 713 def revert_listoflistings(document):
 714     'Convert TOC lstlistoflistings inset to ERT lstlistoflistings'
 715     i = 0
 716     while True:
 717         i = find_token(document.body, "\\begin_inset CommandInset toc", i)
 718         if i == -1:
 719             return
 720         if document.body[i+1] == "LatexCommand lstlistoflistings":
 721             j = find_end_of_inset(document.body, i)
 722             if j == -1:
 723                 document.warning("Malformed lyx document: Can't find end of TOC inset")
 724                 i += 1
 725                 continue
 726             subst = put_cmd_in_ert("\\lstlistoflistings{}")
 727             document.body[i:j+1] = subst
 728             add_to_preamble(document, ["\\usepackage{listings}"])
 729         i = i + 1
 730
 731
 732 def convert_use_amssymb(document):
 733     "insert use_package amssymb"
 734     regexp = re.compile(r'(\\use_package\s+amsmath)')
 735     i = find_re(document.header, regexp, 0)
 736     if i == -1:
 737         document.warning("Malformed LyX document: Can't find \\use_package amsmath.")
 738         return;
 739     value = get_value(document.header, "\\use_package" , i).split()[1]
 740     useamsmath = 0
 741     try:
 742         useamsmath = int(value)
 743     except:
 744         document.warning("Invalid \\use_package amsmath: " + value + ". Assuming auto.")
 745         useamsmath = 1
 746     j = find_token(document.preamble, "\\usepackage{amssymb}", 0)
 747     if j == -1:
 748         document.header.insert(i + 1, "\\use_package amssymb %d" % useamsmath)
 749     else:
 750         document.header.insert(i + 1, "\\use_package amssymb 2")
 751         del document.preamble[j]
 752
 753
 754 def revert_use_amssymb(document):
 755     "remove use_package amssymb"
 756     regexp1 = re.compile(r'(\\use_package\s+amsmath)')
 757     regexp2 = re.compile(r'(\\use_package\s+amssymb)')
 758     i = find_re(document.header, regexp1, 0)
 759     j = find_re(document.header, regexp2, 0)
 760     value1 = "1" # default is auto
 761     value2 = "1" # default is auto
 762     if i != -1:
 763         value1 = get_value(document.header, "\\use_package" , i).split()[1]
 764     if j != -1:
 765         value2 = get_value(document.header, "\\use_package" , j).split()[1]
 766         del document.header[j]
 767     if value1 != value2 and value2 == "2": # on
 768         add_to_preamble(document, ["\\usepackage{amssymb}"])
 769
 770
 771 ##
 772 # Conversion hub
 773 #
 774
 775 supported_versions = ["2.1.0","2.1"]
 776 convert = [
 777            [414, []],
 778            [415, [convert_undertilde]],
 779            [416, []],
 780            [417, [convert_japanese_encodings]],
 781            [418, []],
 782            [419, []],
 783            [420, [convert_biblio_style]],
 784            [421, [convert_longtable_captions]],
 785            [422, [convert_use_packages]],
 786            [423, [convert_use_mathtools]],
 787            [424, [convert_cite_engine_type]],
 788            [425, []],
 789            [426, []],
 790            [427, []],
 791            [428, [convert_cell_rotation]],
 792            [429, [convert_table_rotation]],
 793            [430, [convert_listoflistings]],
 794            [431, [convert_use_amssymb]],
 795           ]
 796
 797 revert =  [
 798            [430, [revert_use_amssymb]],
 799            [429, [revert_listoflistings]],
 800            [428, [revert_table_rotation]],
 801            [427, [revert_cell_rotation]],
 802            [426, [revert_tipa]],
 803            [425, [revert_verbatim]],
 804            [424, [revert_cancel]],
 805            [423, [revert_cite_engine_type]],
 806            [422, [revert_use_mathtools]],
 807            [421, [revert_use_packages]],
 808            [420, [revert_longtable_captions]],
 809            [419, [revert_biblio_style]],
 810            [418, [revert_australian]],
 811            [417, [revert_justification]],
 812            [416, [revert_japanese_encodings]],
 813            [415, [revert_negative_space, revert_math_spaces]],
 814            [414, [revert_undertilde]],
 815            [413, [revert_visible_space]]
 816           ]
 817
 818
 819 if __name__ == "__main__":
 820     pass