X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=lib%2Flyx2lyx%2Flyx_2_0.py;h=1a7a266193ebb3ee2835154bd0a02a6f9c05b836;hb=2778d96bd280a51165455165f422485a78c4e7e8;hp=ab1230804b814f04b42a8a8a7acf3b386540876e;hpb=65962da47b85682f20f1e060955e5cd9f3399c66;p=lyx.git

diff --git a/lib/lyx2lyx/lyx_2_0.py b/lib/lyx2lyx/lyx_2_0.py
index ab1230804b..1a7a266193 100644
--- a/lib/lyx2lyx/lyx_2_0.py
+++ b/lib/lyx2lyx/lyx_2_0.py
@@ -23,85 +23,24 @@ import re, string
 import unicodedata
 import sys, os
 
-from parser_tools import find_token, find_end_of, find_tokens, get_value, get_value_string
+from parser_tools import find_token, find_end_of, find_tokens, \
+  find_end_of_inset, find_end_of_layout, get_value, get_value_string
+  
+from lyx2lyx_tools import add_to_preamble, insert_to_preamble, \
+  put_cmd_in_ert, lyx2latex, latex_length, revert_flex_inset, \
+  revert_font_attrs, revert_layout_command, hex2ratio
 
 ####################################################################
 # Private helper functions
 
 def remove_option(document, m, option):
+    ''' removes option from line m. returns whether we did anything '''
     l = document.body[m].find(option)
-    if l != -1:
-        val = document.body[m][l:].split('"')[1]
-        document.body[m] = document.body[m][:l - 1] + document.body[m][l+len(option + '="' + val + '"'):]
-    return l
-
-def find_end_of_inset(lines, i):
-    " Find end of inset, where lines[i] is included."
-    return find_end_of(lines, i, "\\begin_inset", "\\end_inset")
-
-
-# Note that text can be either a list of lines or a single line.
-def add_to_preamble(document, text):
-    """ Add text to the preamble if it is not already there.
-    Only the first line is checked!"""
-
-    if not type(text) is list:
-      # split on \n just in case
-      # it'll give us the one element list we want
-      # if there's no \n, too
-      text = text.split('\n')
-
-    if find_token(document.preamble, text[0], 0) != -1:
-        return
-
-    document.preamble.extend(text)
-
-
-def insert_to_preamble(index, document, text):
-    """ Insert text to the preamble at a given line"""
-
-    document.preamble.insert(index, text)
-
-
-def read_unicodesymbols():
-    " Read the unicodesymbols list of unicode characters and corresponding commands."
-    pathname = os.path.abspath(os.path.dirname(sys.argv[0]))
-    fp = open(os.path.join(pathname.strip('lyx2lyx'), 'unicodesymbols'))
-    spec_chars = []
-    # Two backslashes, followed by some non-word character, and then a character
-    # in brackets. The idea is to check for constructs like: \"{u}, which is how
-    # they are written in the unicodesymbols file; but they can also be written
-    # as: \"u or even \" u.
-    r = re.compile(r'\\\\(\W)\{(\w)\}')
-    for line in fp.readlines():
-        if line[0] != '#' and line.strip() != "":
-            line=line.replace(' "',' ') # remove all quotation marks with spaces before
-            line=line.replace('" ',' ') # remove all quotation marks with spaces after
-            line=line.replace(r'\"','"') # replace \" by " (for characters with diaeresis)
-            try:
-                [ucs4,command,dead] = line.split(None,2)
-                if command[0:1] != "\\":
-                    continue
-                spec_chars.append([command, unichr(eval(ucs4))])
-            except:
-                continue
-            m = r.match(command)
-            if m != None:
-                command = "\\\\"
-                # If the character is a double-quote, then we need to escape it, too,
-                # since it is done that way in the LyX file.
-                if m.group(1) == "\"":
-                    command += "\\"
-                commandbl = command
-                command += m.group(1) + m.group(2)
-                commandbl += m.group(1) + ' ' + m.group(2)
-                spec_chars.append([command, unichr(eval(ucs4))])
-                spec_chars.append([commandbl, unichr(eval(ucs4))])
-    fp.close()
-    return spec_chars
-
-
-unicode_reps = read_unicodesymbols()
+    if l == -1:
+        return False
+    val = document.body[m][l:].split('"')[1]
+    document.body[m] = document.body[m][:l - 1] + document.body[m][l+len(option + '="' + val + '"'):]
+    return True
 
 
 # DO NOT USE THIS ROUTINE ANY MORE. Better yet, replace the uses that
@@ -115,304 +54,11 @@ def old_put_cmd_in_ert(string):
     return string
 
 
-# This routine wraps some content in an ERT inset. 
-#
-# NOTE: The function accepts either a single string or a LIST of strings as
-# argument. But it returns a LIST of strings, split on \n, so that it does 
-# not have embedded newlines.
-# 
-# This is how lyx2lyx represents a LyX document: as a list of strings, 
-# each representing a line of a LyX file. Embedded newlines confuse 
-# lyx2lyx very much.
-#
-# A call to this routine will often go something like this:
-#   i = find_token('\\begin_inset FunkyInset', ...)
-#   ...
-#   j = find_end_of_inset(document.body, i)
-#   content = ...extract content from insets
-#   # that could be as simple as: 
-#   # content = lyx2latex(document[i:j + 1])
-#   ert = put_cmd_in_ert(content)
-#   document.body[i:j] = ert
-# Now, before we continue, we need to reset i appropriately. Normally,
-# this would be: 
-#   i += len(ert)
-# That puts us right after the ERT we just inserted.
-#
-def put_cmd_in_ert(arg):
-    ret = ["\\begin_inset ERT", "status collapsed", "\\begin_layout Plain Layout", ""]
-    # Despite the warnings just given, it will be faster for us to work
-    # with a single string internally. That way, we only go through the
-    # unicode_reps loop once.
-    if type(arg) is list:
-      s = "\n".join(arg)
-    else:
-      s = arg
-    for rep in unicode_reps:
-      s = s.replace(rep[1], rep[0].replace('\\\\', '\\'))
-    s = s.replace('\\', "\\backslash\n")
-    ret += s.splitlines()
-    ret += ["\\end_layout", "\\end_inset"]
-    return ret
-
-            
-def lyx2latex(document, lines):
-    'Convert some LyX stuff into corresponding LaTeX stuff, as best we can.'
-    # clean up multiline stuff
-    content = ""
-    ert_end = 0
-    note_end = 0
-    hspace = ""
-
-    for curline in range(len(lines)):
-      line = lines[curline]
-      if line.startswith("\\begin_inset Note Note"):
-          # We want to skip LyX notes, so remember where the inset ends
-          note_end = find_end_of_inset(lines, curline + 1)
-          continue
-      elif note_end >= curline:
-          # Skip LyX notes
-          continue
-      elif line.startswith("\\begin_inset ERT"):
-          # We don't want to replace things inside ERT, so figure out
-          # where the end of the inset is.
-          ert_end = find_end_of_inset(lines, curline + 1)
-          continue
-      elif line.startswith("\\begin_inset Formula"):
-          line = line[20:]
-      elif line.startswith("\\begin_inset Quotes"):
-          # For now, we do a very basic reversion. Someone who understands
-          # quotes is welcome to fix it up.
-          qtype = line[20:].strip()
-          # lang = qtype[0]
-          side = qtype[1]
-          dbls = qtype[2]
-          if side == "l":
-              if dbls == "d":
-                  line = "``"
-              else:
-                  line = "`"
-          else:
-              if dbls == "d":
-                  line = "''"
-              else:
-                  line = "'"
-      elif line.startswith("\\begin_inset space"):
-          line = line[18:].strip()
-          if line.startswith("\\hspace"):
-              # Account for both \hspace and \hspace*
-              hspace = line[:-2]
-              continue
-          elif line == "\\space{}":
-              line = "\\ "
-          elif line == "\\thinspace{}":
-              line = "\\,"
-      elif hspace != "":
-          # The LyX length is in line[8:], after the \length keyword
-          # latex_length returns "bool,length"
-          length = latex_length(line[8:]).split(",")[1]
-          line = hspace + "{" + length + "}"
-          hspace = ""
-      elif line.isspace() or \
-            line.startswith("\\begin_layout") or \
-            line.startswith("\\end_layout") or \
-            line.startswith("\\begin_inset") or \
-            line.startswith("\\end_inset") or \
-            line.startswith("\\lang") or \
-            line.strip() == "status collapsed" or \
-            line.strip() == "status open":
-          #skip all that stuff
-          continue
-
-      # this needs to be added to the preamble because of cases like
-      # \textmu, \textbackslash, etc.
-      add_to_preamble(document, ['% added by lyx2lyx for converted index entries',
-                                 '\\@ifundefined{textmu}',
-                                 ' {\\usepackage{textcomp}}{}'])
-      # a lossless reversion is not possible
-      # try at least to handle some common insets and settings
-      if ert_end >= curline:
-          line = line.replace(r'\backslash', '\\')
-      else:
-          # No need to add "{}" after single-nonletter macros
-          line = line.replace('&', '\\&')
-          line = line.replace('#', '\\#')
-          line = line.replace('^', '\\textasciicircum{}')
-          line = line.replace('%', '\\%')
-          line = line.replace('_', '\\_')
-          line = line.replace('$', '\\$')
-
-          # Do the LyX text --> LaTeX conversion
-          for rep in unicode_reps:
-            line = line.replace(rep[1], rep[0] + "{}")
-          line = line.replace(r'\backslash', r'\textbackslash{}')
-          line = line.replace(r'\series bold', r'\bfseries{}').replace(r'\series default', r'\mdseries{}')
-          line = line.replace(r'\shape italic', r'\itshape{}').replace(r'\shape smallcaps', r'\scshape{}')
-          line = line.replace(r'\shape slanted', r'\slshape{}').replace(r'\shape default', r'\upshape{}')
-          line = line.replace(r'\emph on', r'\em{}').replace(r'\emph default', r'\em{}')
-          line = line.replace(r'\noun on', r'\scshape{}').replace(r'\noun default', r'\upshape{}')
-          line = line.replace(r'\bar under', r'\underbar{').replace(r'\bar default', r'}')
-          line = line.replace(r'\family sans', r'\sffamily{}').replace(r'\family default', r'\normalfont{}')
-          line = line.replace(r'\family typewriter', r'\ttfamily{}').replace(r'\family roman', r'\rmfamily{}')
-          line = line.replace(r'\InsetSpace ', r'').replace(r'\SpecialChar ', r'')
-      content += line
-    return content
-
-
-def latex_length(string):
-    'Convert lengths to their LaTeX representation.'
-    i = 0
-    percent = False
-    # the string has the form
-    # ValueUnit+ValueUnit-ValueUnit or
-    # ValueUnit+-ValueUnit
-    # the + and - (glue lengths) are optional
-    # the + always precedes the -
-
-    # Convert relative lengths to LaTeX units
-    units = {"text%":"\\textwidth", "col%":"\\columnwidth",
-             "page%":"\\paperwidth", "line%":"\\linewidth",
-             "theight%":"\\textheight", "pheight%":"\\paperheight"}
-    for unit in units.keys():
-        i = string.find(unit)
-        if i != -1:
-            percent = True
-            minus = string.rfind("-", 1, i)
-            plus = string.rfind("+", 0, i)
-            latex_unit = units[unit]
-            if plus == -1 and minus == -1:
-                value = string[:i]
-                value = str(float(value)/100)
-                end = string[i + len(unit):]
-                string = value + latex_unit + end
-            if plus > minus:
-                value = string[plus + 1:i]
-                value = str(float(value)/100)
-                begin = string[:plus + 1]
-                end = string[i+len(unit):]
-                string = begin + value + latex_unit + end
-            if plus < minus:
-                value = string[minus + 1:i]
-                value = str(float(value)/100)
-                begin = string[:minus + 1]
-                string = begin + value + latex_unit
-
-    # replace + and -, but only if the - is not the first character
-    string = string[0] + string[1:].replace("+", " plus ").replace("-", " minus ")
-    # handle the case where "+-1mm" was used, because LaTeX only understands
-    # "plus 1mm minus 1mm"
-    if string.find("plus  minus"):
-        lastvaluepos = string.rfind(" ")
-        lastvalue = string[lastvaluepos:]
-        string = string.replace("  ", lastvalue + " ")
-    if percent ==  False:
-        return "False," + string
-    else:
-        return "True," + string
-
-
-def revert_flex_inset(document, name, LaTeXname, position):
-  " Convert flex insets to TeX code "
-  i = position
-  while True:
-    i = find_token(document.body, '\\begin_inset Flex ' + name, i)
-    if i == -1:
-      return
-    z = find_end_of_inset(document.body, i)
-    if z == -1:
-      document.warning("Malformed LyX document: Can't find end of Flex " + name + " inset.")
-      return
-    # remove the \end_inset
-    document.body[z - 2:z + 1] = put_cmd_in_ert("}")
-    # we need to reset character layouts if necessary
-    j = find_token(document.body, '\\emph on', i)
-    k = find_token(document.body, '\\noun on', i)
-    l = find_token(document.body, '\\series', i)
-    m = find_token(document.body, '\\family', i)
-    n = find_token(document.body, '\\shape', i)
-    o = find_token(document.body, '\\color', i)
-    p = find_token(document.body, '\\size', i)
-    q = find_token(document.body, '\\bar under', i)
-    r = find_token(document.body, '\\uuline on', i)
-    s = find_token(document.body, '\\uwave on', i)
-    t = find_token(document.body, '\\strikeout on', i)
-    if j != -1 and j < z:
-      document.body.insert(z - 2, "\\emph default")
-    if k != -1 and k < z:
-      document.body.insert(z - 2, "\\noun default")
-    if l != -1 and l < z:
-      document.body.insert(z - 2, "\\series default")
-    if m != -1 and m < z:
-      document.body.insert(z - 2, "\\family default")
-    if n != -1 and n < z:
-      document.body.insert(z - 2, "\\shape default")
-    if o != -1 and o < z:
-      document.body.insert(z - 2, "\\color inherit")
-    if p != -1 and p < z:
-      document.body.insert(z - 2, "\\size default")
-    if q != -1 and q < z:
-      document.body.insert(z - 2, "\\bar default")
-    if r != -1 and r < z:
-      document.body.insert(z - 2, "\\uuline default")
-    if s != -1 and s < z:
-      document.body.insert(z - 2, "\\uwave default")
-    if t != -1 and t < z:
-      document.body.insert(z - 2, "\\strikeout default")
-    document.body[i:i + 4] = put_cmd_in_ert(LaTeXname + "{")
-    i += 1
-
-
-def revert_charstyles(document, name, LaTeXname, changed):
-  " Reverts character styles to TeX code "
-  i = 0
-  while True:
-    i = find_token(document.body, name + ' on', i)
-    if i == -1:
-      return changed
-    j = find_token(document.body, name + ' default', i)
-    k = find_token(document.body, name + ' on', i + 1)
-    # if there is no default set, the style ends with the layout
-    # assure hereby that we found the correct layout end
-    if j != -1 and (j < k or k == -1):
-      document.body[j:j + 1] = put_cmd_in_ert("}")
-    else:
-      j = find_token(document.body, '\\end_layout', i)
-      document.body[j:j] = put_cmd_in_ert("}")
-    document.body[i:i + 1] = put_cmd_in_ert(LaTeXname + "{")
-    changed = True
-    i += 1
-
-
-def revert_layout_command(document, name, LaTeXname, position):
-  " Reverts a command from a layout to TeX code "
-  i = position
-  while True:
-    i = find_token(document.body, '\\begin_layout ' + name, i)
-    if i == -1:
-      return
-    k = -1
-    # find the next layout
-    j = i + 1
-    while k == -1:
-      j = find_token(document.body, '\\begin_layout', j)
-      l = len(document.body)
-      # if nothing was found it was the last layout of the document
-      if j == -1:
-        document.body[l - 4:l - 4] = put_cmd_in_ert("}")
-        k = 0
-      # exclude plain layout because this can be TeX code or another inset
-      elif document.body[j] != '\\begin_layout Plain Layout':
-        document.body[j - 2:j - 2] = put_cmd_in_ert("}")
-        k = 0
-      else:
-        j += 1
-    document.body[i] = '\\begin_layout Standard'
-    document.body[i + 1:i + 1] = put_cmd_in_ert(LaTeXname + "{")
-    i += 1
-
-
-####################################################################
-
+###############################################################################
+###
+### Conversion and reversion routines
+###
+###############################################################################
 
 def revert_swiss(document):
     " Set language german-ch to ngerman "
@@ -435,146 +81,114 @@ def revert_tabularvalign(document):
    " Revert the tabular valign option "
    i = 0
    while True:
-       i = find_token(document.body, "\\begin_inset Tabular", i)
-       if i == -1:
-           return
-       j = find_token(document.body, "</cell>", i)
-       if j == -1:
-           document.warning("Malformed LyX document: Could not find end of tabular cell.")
-           i = j
-           continue
-       # don't set a box for longtables, only delete tabularvalignment
-       # the alignment is 2 lines below \\begin_inset Tabular
-       p = document.body[i + 2].find("islongtable")
-       if p > -1:
-           q = document.body[i + 2].find("tabularvalignment")
-           if q > -1:
-               document.body[i + 2] = document.body[i + 2][:q - 1]
-               document.body[i + 2] = document.body[i + 2] + '>'
-           i = i + 1
-
-       # when no longtable
-       if p == -1:
-         tabularvalignment = 'c'
-         # which valignment is specified?
-         m = document.body[i + 2].find('tabularvalignment="top"')
-         if m > -1:
-             tabularvalignment = 't'
-         m = document.body[ i+ 2].find('tabularvalignment="bottom"')
-         if m > -1:
-             tabularvalignment = 'b'
-         # delete tabularvalignment
-         q = document.body[i + 2].find("tabularvalignment")
-         if q > -1:
-             document.body[i + 2] = document.body[i + 2][:q - 1]
-             document.body[i + 2] = document.body[i + 2] + '>'
-
-         # don't add a box when centered
-         if tabularvalignment == 'c':
-             i = j
-             continue
-         subst = ['\\end_layout', '\\end_inset']
-         document.body[j:j] = subst # just inserts those lines
-         subst = ['\\begin_inset Box Frameless',
-             'position "' + tabularvalignment +'"',
-             'hor_pos "c"',
-             'has_inner_box 1',
-             'inner_pos "c"',
-             'use_parbox 0',
-             # we don't know the width, assume 50%
-             'width "50col%"',
-             'special "none"',
-             'height "1in"',
-             'height_special "totalheight"',
-             'status open',
-             '',
-             '\\begin_layout Plain Layout']
-         document.body[i:i] = subst # this just inserts the array at i
-         i += len(subst) + 2 # adjust i to save a few cycles
+      i = find_token(document.body, "\\begin_inset Tabular", i)
+      if i == -1:
+          return
+      end = find_end_of_inset(document.body, i)
+      if end == -1:
+          document.warning("Can't find end of inset at line " + str(i))
+          i += 1
+          continue
+      fline = find_token(document.body, "<features", i, end)
+      if fline == -1:
+          document.warning("Can't find features for inset at line " + str(i))
+          i += 1
+          continue
+      p = document.body[fline].find("islongtable")
+      if p != -1:
+          q = document.body[fline].find("tabularvalignment")
+          if q != -1:
+              # FIXME
+              # This seems wrong: It removes everything after 
+              # tabularvalignment, too.
+              document.body[fline] = document.body[fline][:q - 1] + '>'
+          i += 1
+          continue
+
+       # no longtable
+      tabularvalignment = 'c'
+      # which valignment is specified?
+      m = document.body[fline].find('tabularvalignment="top"')
+      if m != -1:
+          tabularvalignment = 't'
+      m = document.body[fline].find('tabularvalignment="bottom"')
+      if m != -1:
+          tabularvalignment = 'b'
+      # delete tabularvalignment
+      q = document.body[fline].find("tabularvalignment")
+      if q != -1:
+          # FIXME
+          # This seems wrong: It removes everything after 
+          # tabularvalignment, too.
+          document.body[fline] = document.body[fline][:q - 1] + '>'
+
+      # don't add a box when centered
+      if tabularvalignment == 'c':
+          i = end
+          continue
+      subst = ['\\end_layout', '\\end_inset']
+      document.body[end:end] = subst # just inserts those lines
+      subst = ['\\begin_inset Box Frameless',
+          'position "' + tabularvalignment +'"',
+          'hor_pos "c"',
+          'has_inner_box 1',
+          'inner_pos "c"',
+          'use_parbox 0',
+          # we don't know the width, assume 50%
+          'width "50col%"',
+          'special "none"',
+          'height "1in"',
+          'height_special "totalheight"',
+          'status open',
+          '',
+          '\\begin_layout Plain Layout']
+      document.body[i:i] = subst # this just inserts the array at i
+      # since there could be a tabular inside a tabular, we cannot
+      # jump to end
+      i += len(subst)
 
 
-def revert_phantom(document):
+def revert_phantom_types(document, ptype, cmd):
     " Reverts phantom to ERT "
     i = 0
-    j = 0
     while True:
-      i = find_token(document.body, "\\begin_inset Phantom Phantom", i)
+      i = find_token(document.body, "\\begin_inset Phantom " + ptype, i)
       if i == -1:
           return
-      substi = document.body[i].replace('\\begin_inset Phantom Phantom', \
-                '\\begin_inset ERT\nstatus collapsed\n\n' \
-                '\\begin_layout Plain Layout\n\n\n\\backslash\n' \
-                'phantom{\n\\end_layout\n\n\\end_inset\n')
-      substi = substi.split('\n')
-      document.body[i:i + 4] = substi
-      i += len(substi)
-      j = find_token(document.body, "\\end_layout", i)
-      if j == -1:
-          document.warning("Malformed LyX document: Could not find end of Phantom inset.")
-          return
-      substj = document.body[j].replace('\\end_layout', \
-                '\\size default\n\n\\begin_inset ERT\nstatus collapsed\n\n' \
-                '\\begin_layout Plain Layout\n\n' \
-                '}\n\\end_layout\n\n\\end_inset\n')
-      substj = substj.split('\n')
-      document.body[j:j + 4] = substj
-      i += len(substj)
+      end = find_end_of_inset(document.body, i)
+      if end == -1:
+          document.warning("Can't find end of inset at line " + str(i))
+          i += 1
+          continue
+      blay = find_token(document.body, "\\begin_layout Plain Layout", i, end)
+      if blay == -1:
+          document.warning("Can't find layout for inset at line " + str(i))
+          i = end
+          continue
+      bend = find_token(document.body, "\\end_layout", blay, end)
+      if bend == -1:
+          document.warning("Malformed LyX document: Could not find end of Phantom inset's layout.")
+          i = end
+          continue
+      substi = ["\\begin_inset ERT", "status collapsed", "",
+                "\\begin_layout Plain Layout", "", "", "\\backslash", 
+                cmd + "{", "\\end_layout", "", "\\end_inset"]
+      substj = ["\\size default", "", "\\begin_inset ERT", "status collapsed", "",
+                "\\begin_layout Plain Layout", "", "}", "\\end_layout", "", "\\end_inset"]
+      # do the later one first so as not to mess up the numbering
+      document.body[bend:end + 1] = substj
+      document.body[i:blay + 1] = substi
+      i = end + len(substi) + len(substj) - (end - bend) - (blay - i) - 2
 
 
+def revert_phantom(document):
+    revert_phantom_types(document, "Phantom", "phantom")
+    
 def revert_hphantom(document):
-    " Reverts hphantom to ERT "
-    i = 0
-    j = 0
-    while True:
-      i = find_token(document.body, "\\begin_inset Phantom HPhantom", i)
-      if i == -1:
-          return
-      substi = document.body[i].replace('\\begin_inset Phantom HPhantom', \
-                '\\begin_inset ERT\nstatus collapsed\n\n' \
-                '\\begin_layout Plain Layout\n\n\n\\backslash\n' \
-                'hphantom{\n\\end_layout\n\n\\end_inset\n')
-      substi = substi.split('\n')
-      document.body[i:i + 4] = substi
-      i += len(substi)
-      j = find_token(document.body, "\\end_layout", i)
-      if j == -1:
-          document.warning("Malformed LyX document: Could not find end of HPhantom inset.")
-          return
-      substj = document.body[j].replace('\\end_layout', \
-                '\\size default\n\n\\begin_inset ERT\nstatus collapsed\n\n' \
-                '\\begin_layout Plain Layout\n\n' \
-                '}\n\\end_layout\n\n\\end_inset\n')
-      substj = substj.split('\n')
-      document.body[j:j + 4] = substj
-      i += len(substj)
-
+    revert_phantom_types(document, "HPhantom", "hphantom")
 
 def revert_vphantom(document):
-    " Reverts vphantom to ERT "
-    i = 0
-    j = 0
-    while True:
-      i = find_token(document.body, "\\begin_inset Phantom VPhantom", i)
-      if i == -1:
-          return
-      substi = document.body[i].replace('\\begin_inset Phantom VPhantom', \
-                '\\begin_inset ERT\nstatus collapsed\n\n' \
-                '\\begin_layout Plain Layout\n\n\n\\backslash\n' \
-                'vphantom{\n\\end_layout\n\n\\end_inset\n')
-      substi = substi.split('\n')
-      document.body[i:i + 4] = substi
-      i += len(substi)
-      j = find_token(document.body, "\\end_layout", i)
-      if j == -1:
-          document.warning("Malformed LyX document: Could not find end of VPhantom inset.")
-          return
-      substj = document.body[j].replace('\\end_layout', \
-                '\\size default\n\n\\begin_inset ERT\nstatus collapsed\n\n' \
-                '\\begin_layout Plain Layout\n\n' \
-                '}\n\\end_layout\n\n\\end_inset\n')
-      substj = substj.split('\n')
-      document.body[j:j + 4] = substj
-      i += len(substj)
+    revert_phantom_types(document, "VPhantom", "vphantom")
 
 
 def revert_xetex(document):
@@ -679,40 +293,23 @@ def revert_outputformat(document):
 
 def revert_backgroundcolor(document):
     " Reverts background color to preamble code "
-    i = 0
-    colorcode = ""
-    while True:
-      i = find_token(document.header, "\\backgroundcolor", i)
-      if i == -1:
-          return
-      colorcode = get_value(document.header, '\\backgroundcolor', 0)
-      del document.header[i]
-      # don't clutter the preamble if backgroundcolor is not set
-      if colorcode == "#ffffff":
-          continue
-      # the color code is in the form #rrggbb where every character denotes a hex number
-      # convert the string to an int
-      red = string.atoi(colorcode[1:3],16)
-      # we want the output "0.5" for the value "127" therefore add here
-      if red != 0:
-          red = red + 1
-      redout = float(red) / 256
-      green = string.atoi(colorcode[3:5],16)
-      if green != 0:
-          green = green + 1
-      greenout = float(green) / 256
-      blue = string.atoi(colorcode[5:7],16)
-      if blue != 0:
-          blue = blue + 1
-      blueout = float(blue) / 256
-      # write the preamble
-      insert_to_preamble(0, document,
-                           '% Commands inserted by lyx2lyx to set the background color\n'
-                           + '\\@ifundefined{definecolor}{\\usepackage{color}}{}\n'
-                           + '\\definecolor{page_backgroundcolor}{rgb}{'
-                           + str(redout) + ', ' + str(greenout)
-                           + ', ' + str(blueout) + '}\n'
-                           + '\\pagecolor{page_backgroundcolor}\n')
+    i = find_token(document.header, "\\backgroundcolor", 0)
+    if i == -1:
+        return
+    colorcode = get_value(document.header, '\\backgroundcolor', i)
+    del document.header[i]
+    # don't clutter the preamble if backgroundcolor is not set
+    if colorcode == "#ffffff":
+        return
+    red   = hex2ratio(colorcode[1:3])
+    green = hex2ratio(colorcode[3:5])
+    blue  = hex2ratio(colorcode[5:7])
+    insert_to_preamble(0, document,
+                          '% Commands inserted by lyx2lyx to set the background color\n'
+                          + '\\@ifundefined{definecolor}{\\usepackage{color}}{}\n'
+                          + '\\definecolor{page_backgroundcolor}{rgb}{'
+                          + red + ',' + green + ',' + blue + '}\n'
+                          + '\\pagecolor{page_backgroundcolor}\n')
 
 
 def revert_splitindex(document):
@@ -723,9 +320,12 @@ def revert_splitindex(document):
         return
     indices = get_value(document.header, "\\use_indices", i)
     preamble = ""
-    if indices == "true":
+    useindices = (indices == "true")
+    if useindices:
          preamble += "\\usepackage{splitidx}\n"
     del document.header[i]
+    
+    # deal with index declarations in the preamble
     i = 0
     while True:
         i = find_token(document.header, "\\index", i)
@@ -735,17 +335,20 @@ def revert_splitindex(document):
         if k == -1:
             document.warning("Malformed LyX document: Missing \\end_index.")
             return
-        line = document.header[i]
-        l = re.compile(r'\\index (.*)$')
-        m = l.match(line)
-        iname = m.group(1)
-        ishortcut = get_value(document.header, '\\shortcut', i, k)
-        if ishortcut != "" and indices == "true":
-            preamble += "\\newindex[" + iname + "]{" + ishortcut + "}\n"
+        if useindices:    
+          line = document.header[i]
+          l = re.compile(r'\\index (.*)$')
+          m = l.match(line)
+          iname = m.group(1)
+          ishortcut = get_value(document.header, '\\shortcut', i, k)
+          if ishortcut != "":
+              preamble += "\\newindex[" + iname + "]{" + ishortcut + "}\n"
         del document.header[i:k + 1]
-        i = 0
     if preamble != "":
         insert_to_preamble(0, document, preamble)
+        
+    # deal with index insets
+    # these need to have the argument removed
     i = 0
     while True:
         i = find_token(document.body, "\\begin_inset Index", i)
@@ -760,13 +363,17 @@ def revert_splitindex(document):
         else:
             k = find_end_of_inset(document.body, i)
             if k == -1:
-                 return
+                document.warning("Can't find end of index inset!")
+                i += 1
+                continue
             content = lyx2latex(document, document.body[i:k])
             # escape quotes
             content = content.replace('"', r'\"')
-            subst = [old_put_cmd_in_ert("\\sindex[" + itype + "]{" + content + "}")]
+            subst = put_cmd_in_ert("\\sindex[" + itype + "]{" + content + "}")
             document.body[i:k + 1] = subst
         i = i + 1
+        
+    # deal with index_print insets
     i = 0
     while True:
         i = find_token(document.body, "\\begin_inset CommandInset index_print", i)
@@ -777,10 +384,10 @@ def revert_splitindex(document):
         if ptype == "idx":
             j = find_token(document.body, "type", i, k)
             del document.body[j]
-        elif indices == "false":
+        elif not useindices:
             del document.body[i:k + 1]
         else:
-            subst = [old_put_cmd_in_ert("\\printindex[" + ptype + "]{}")]
+            subst = put_cmd_in_ert("\\printindex[" + ptype + "]{}")
             document.body[i:k + 1] = subst
         i = i + 1
 
@@ -816,6 +423,7 @@ def revert_subindex(document):
         document.warning("Malformed LyX document: Missing \\use_indices.")
         return
     indices = get_value(document.header, "\\use_indices", i)
+    useindices = (indices == "true")
     i = 0
     while True:
         i = find_token(document.body, "\\begin_inset CommandInset index_print", i)
@@ -824,13 +432,13 @@ def revert_subindex(document):
         k = find_end_of_inset(document.body, i)
         ctype = get_value(document.body, 'LatexCommand', i, k)
         if ctype != "printsubindex":
-            i = i + 1
+            i = k + 1
             continue
         ptype = get_value(document.body, 'type', i, k).strip('"')
-        if indices == "false":
+        if not useindices:
             del document.body[i:k + 1]
         else:
-            subst = [old_put_cmd_in_ert("\\printsubindex[" + ptype + "]{}")]
+            subst = put_cmd_in_ert("\\printsubindex[" + ptype + "]{}")
             document.body[i:k + 1] = subst
         i = i + 1
 
@@ -842,6 +450,7 @@ def revert_printindexall(document):
         document.warning("Malformed LyX document: Missing \\use_indices.")
         return
     indices = get_value(document.header, "\\use_indices", i)
+    useindices = (indices == "true")
     i = 0
     while True:
         i = find_token(document.body, "\\begin_inset CommandInset index_print", i)
@@ -850,22 +459,21 @@ def revert_printindexall(document):
         k = find_end_of_inset(document.body, i)
         ctype = get_value(document.body, 'LatexCommand', i, k)
         if ctype != "printindex*" and ctype != "printsubindex*":
-            i = i + 1
+            i = k
             continue
-        if indices == "false":
+        if not useindices:
             del document.body[i:k + 1]
         else:
-            subst = [old_put_cmd_in_ert("\\" + ctype + "{}")]
+            subst = put_cmd_in_ert("\\" + ctype + "{}")
             document.body[i:k + 1] = subst
         i = i + 1
 
 
 def revert_strikeout(document):
-  " Reverts \\strikeout character style "
-  changed = False
-  changed = revert_charstyles(document, "\\uuline", "\\uuline", changed)
-  changed = revert_charstyles(document, "\\uwave", "\\uwave", changed)
-  changed = revert_charstyles(document, "\\strikeout", "\\sout", changed)
+  " Reverts \\strikeout font attribute "
+  changed = revert_font_attrs(document, "\\uuline", "\\uuline")
+  changed = revert_font_attrs(document, "\\uwave", "\\uwave") or changed
+  changed = revert_font_attrs(document, "\\strikeout", "\\sout")  or changed
   if changed == True:
     insert_to_preamble(0, document,
         '% Commands inserted by lyx2lyx for proper underlining\n'
@@ -874,7 +482,7 @@ def revert_strikeout(document):
 
 
 def revert_ulinelatex(document):
-    " Reverts \\uline character style "
+    " Reverts \\uline font attribute "
     i = find_token(document.body, '\\bar under', 0)
     if i == -1:
         return
@@ -893,13 +501,13 @@ def revert_custom_processors(document):
     i = find_token(document.header, '\\bibtex_command', 0)
     if i == -1:
         document.warning("Malformed LyX document: Missing \\bibtex_command.")
-        return
-    del document.header[i]
+    else:
+        del document.header[i]
     i = find_token(document.header, '\\index_command', 0)
     if i == -1:
         document.warning("Malformed LyX document: Missing \\index_command.")
-        return
-    del document.header[i]
+    else:
+        del document.header[i]
 
 
 def convert_nomencl_width(document):
@@ -927,7 +535,7 @@ def revert_nomencl_width(document):
             i = j
             continue
       del document.body[l]
-      i = i + 1
+      i = j - 1
 
 
 def revert_nomencl_cwidth(document):
@@ -940,41 +548,53 @@ def revert_nomencl_cwidth(document):
       j = find_end_of_inset(document.body, i)
       l = find_token(document.body, "width", i, j)
       if l == -1:
-            #Can't find width option for nomencl_print
-            i = j
-            continue
+        document.warning("Can't find width option for nomencl_print!")
+        i = j
+        continue
       width = get_value(document.body, "width", i, j).strip('"')
       del document.body[l]
       add_to_preamble(document, ["% this command was inserted by lyx2lyx"])
       add_to_preamble(document, ["\\setlength{\\nomlabelwidth}{" + width + "}"])
-      i = i + 1
+      i = j - 1
 
 
 def revert_applemac(document):
     " Revert applemac encoding to auto "
-    i = 0
-    if document.encoding == "applemac":
-        document.encoding = "auto"
-        i = find_token(document.header, "\\encoding", 0)
-        if i != -1:
-            document.header[i] = "\\encoding auto"
+    if document.encoding != "applemac":
+      return
+    document.encoding = "auto"
+    i = find_token(document.header, "\\encoding", 0)
+    if i != -1:
+        document.header[i] = "\\encoding auto"
 
 
 def revert_longtable_align(document):
     " Remove longtable alignment setting "
     i = 0
-    j = 0
     while True:
       i = find_token(document.body, "\\begin_inset Tabular", i)
       if i == -1:
           break
-      # the alignment is 2 lines below \\begin_inset Tabular
-      j = document.body[i + 2].find("longtabularalignment")
+      end = find_end_of_inset(document.body, i)
+      if end == -1:
+          document.warning("Can't find end of inset at line " + str(i))
+          i += 1
+          continue
+      fline = find_token(document.body, "<features", i, end)
+      if fline == -1:
+          document.warning("Can't find features for inset at line " + str(i))
+          i += 1
+          continue
+      j = document.body[fline].find("longtabularalignment")
       if j == -1:
-          break
-      document.body[i + 2] = document.body[i + 2][:j - 1]
-      document.body[i + 2] = document.body[i + 2] + '>'
-      i = i + 1
+          i += 1
+          continue
+      # FIXME Is this correct? It wipes out everything after the 
+      # one we found.
+      document.body[fline] = document.body[fline][:j - 1] + '>'
+      # since there could be a tabular inside this one, we 
+      # cannot jump to end.
+      i += 1
 
 
 def revert_branch_filename(document):
@@ -989,49 +609,36 @@ def revert_branch_filename(document):
 
 def revert_paragraph_indentation(document):
     " Revert custom paragraph indentation to preamble code "
-    i = 0
-    while True:
-      i = find_token(document.header, "\\paragraph_indentation", i)
-      if i == -1:
-          break
-      # only remove the preamble line if default
-      # otherwise also write the value to the preamble
-      length = get_value(document.header, "\\paragraph_indentation", i)
-      if length == "default":
-          del document.header[i]
-          break
-      else:
-          # handle percent lengths
-          # latex_length returns "bool,length"
-          length = latex_length(length).split(",")[1]
-          add_to_preamble(document, ["% this command was inserted by lyx2lyx"])
-          add_to_preamble(document, ["\\setlength{\\parindent}{" + length + "}"])
-          del document.header[i]
-      i = i + 1
+    i = find_token(document.header, "\\paragraph_indentation", 0)
+    if i == -1:
+      return
+    length = get_value(document.header, "\\paragraph_indentation", i)
+    # we need only remove the line if indentation is default
+    if length != "default":
+      # handle percent lengths
+      length = latex_length(length)[1]
+      add_to_preamble(document, ["% this command was inserted by lyx2lyx"])
+      add_to_preamble(document, ["\\setlength{\\parindent}{" + length + "}"])
+    del document.header[i]
 
 
 def revert_percent_skip_lengths(document):
     " Revert relative lengths for paragraph skip separation to preamble code "
-    i = 0
-    while True:
-      i = find_token(document.header, "\\defskip", i)
-      if i == -1:
-          break
-      length = get_value(document.header, "\\defskip", i)
-      # only revert when a custom length was set and when
-      # it used a percent length
-      if length not in ('smallskip', 'medskip', 'bigskip'):
-          # handle percent lengths
-          length = latex_length(length)
-          # latex_length returns "bool,length"
-          percent = length.split(",")[0]
-          length = length.split(",")[1]
-          if percent == "True":
-              add_to_preamble(document, ["% this command was inserted by lyx2lyx"])
-              add_to_preamble(document, ["\\setlength{\\parskip}{" + length + "}"])
-              # set defskip to medskip as default
-              document.header[i] = "\\defskip medskip"
-      i = i + 1
+    i = find_token(document.header, "\\defskip", 0)
+    if i == -1:
+        return
+    length = get_value(document.header, "\\defskip", i)
+    # only revert when a custom length was set and when
+    # it used a percent length
+    if length in ('smallskip', 'medskip', 'bigskip'):
+        return
+    # handle percent lengths
+    percent, length = latex_length(length)
+    if percent:
+        add_to_preamble(document, ["% this command was inserted by lyx2lyx"])
+        add_to_preamble(document, ["\\setlength{\\parskip}{" + length + "}"])
+        # set defskip to medskip as default
+        document.header[i] = "\\defskip medskip"
 
 
 def revert_percent_vspace_lengths(document):
@@ -1043,28 +650,26 @@ def revert_percent_vspace_lengths(document):
           break
       # only revert if a custom length was set and if
       # it used a percent length
-      line = document.body[i]
       r = re.compile(r'\\begin_inset VSpace (.*)$')
-      m = r.match(line)
+      m = r.match(document.body[i])
       length = m.group(1)
-      if length not in ('defskip', 'smallskip', 'medskip', 'bigskip', 'vfill'):
-          # check if the space has a star (protected space)
-          protected = (document.body[i].rfind("*") != -1)
+      if length in ('defskip', 'smallskip', 'medskip', 'bigskip', 'vfill'):
+         i += 1
+         continue
+      # check if the space has a star (protected space)
+      protected = (document.body[i].rfind("*") != -1)
+      if protected:
+          length = length.rstrip('*')
+      # handle percent lengths
+      percent, length = latex_length(length)
+      # revert the VSpace inset to ERT
+      if percent:
           if protected:
-              length = length.rstrip('*')
-          # handle percent lengths
-          length = latex_length(length)
-          # latex_length returns "bool,length"
-          percent = length.split(",")[0]
-          length = length.split(",")[1]
-          # revert the VSpace inset to ERT
-          if percent == "True":
-              if protected:
-                  subst = [old_put_cmd_in_ert("\\vspace*{" + length + "}")]
-              else:
-                  subst = [old_put_cmd_in_ert("\\vspace{" + length + "}")]
-              document.body[i:i + 2] = subst
-      i = i + 1
+              subst = put_cmd_in_ert("\\vspace*{" + length + "}")
+          else:
+              subst = put_cmd_in_ert("\\vspace{" + length + "}")
+          document.body[i:i + 2] = subst
+      i += 1
 
 
 def revert_percent_hspace_lengths(document):
@@ -1074,26 +679,28 @@ def revert_percent_hspace_lengths(document):
       i = find_token(document.body, "\\begin_inset space \\hspace", i)
       if i == -1:
           break
-      protected = (document.body[i].find("\\hspace*{}") != -1)
-      # only revert if a custom length was set and if
-      # it used a percent length
-      length = get_value(document.body, '\\length', i + 1)
+      j = find_end_of_inset(document.body, i)
+      if j == -1:
+          document.warning("Can't find end of inset at line " + str(i))
+          i += 1
+          continue
+      # only revert if a custom length was set...
+      length = get_value(document.body, '\\length', i + 1, j)
       if length == '':
           document.warning("Malformed lyx document: Missing '\\length' in Space inset.")
-          return
-      # handle percent lengths
-      length = latex_length(length)
-      # latex_length returns "bool,length"
-      percent = length.split(",")[0]
-      length = length.split(",")[1]
+          i = j
+          continue
+      protected = ""
+      if document.body[i].find("\\hspace*{}") != -1:
+          protected = "*"
+      # ...and if it used a percent length
+      percent, length = latex_length(length)
       # revert the HSpace inset to ERT
-      if percent == "True":
-          if protected:
-              subst = [old_put_cmd_in_ert("\\hspace*{" + length + "}")]
-          else:
-              subst = [old_put_cmd_in_ert("\\hspace{" + length + "}")]
-          document.body[i:i + 3] = subst
-      i = i + 2
+      if percent:
+          subst = put_cmd_in_ert("\\hspace" + protected + "{" + length + "}")
+          document.body[i:j + 1] = subst
+      # if we did a substitution, this will still be ok
+      i = j
 
 
 def revert_hspace_glue_lengths(document):
@@ -1103,146 +710,145 @@ def revert_hspace_glue_lengths(document):
       i = find_token(document.body, "\\begin_inset space \\hspace", i)
       if i == -1:
           break
-      protected = (document.body[i].find("\\hspace*{}") != -1)
-      length = get_value(document.body, '\\length', i + 1)
+      j = find_end_of_inset(document.body, i)
+      if j == -1:
+          document.warning("Can't find end of inset at line " + str(i))
+          i += 1
+          continue
+      length = get_value(document.body, '\\length', i + 1, j)
       if length == '':
           document.warning("Malformed lyx document: Missing '\\length' in Space inset.")
-          return
+          i = j
+          continue
+      protected = ""
+      if document.body[i].find("\\hspace*{}") != -1:
+          protected = "*"
       # only revert if the length contains a plus or minus at pos != 0
-      glue  = re.compile(r'.+[\+-]')
-      if glue.search(length):
+      if length.find('-',1) != -1 or length.find('+',1) != -1:
           # handle percent lengths
-          # latex_length returns "bool,length"
-          length = latex_length(length).split(",")[1]
+          length = latex_length(length)[1]
           # revert the HSpace inset to ERT
-          if protected:
-              subst = [old_put_cmd_in_ert("\\hspace*{" + length + "}")]
-          else:
-              subst = [old_put_cmd_in_ert("\\hspace{" + length + "}")]
-          document.body[i:i + 3] = subst
-      i = i + 2
+          subst = put_cmd_in_ert("\\hspace" + protected + "{" + length + "}")
+          document.body[i:j+1] = subst
+      i = j
+
 
 def convert_author_id(document):
     " Add the author_id to the \\author definition and make sure 0 is not used"
     i = 0
-    j = 1
+    anum = 1
+    re_author = re.compile(r'(\\author) (\".*\")\s*(.*)$')
+    
     while True:
         i = find_token(document.header, "\\author", i)
         if i == -1:
             break
-        
-        r = re.compile(r'(\\author) (\".*\")\s?(.*)$')
-        m = r.match(document.header[i])
-        if m != None:
+        m = re_author.match(document.header[i])
+        if m:
             name = m.group(2)
-            
-            email = ''
-            if m.lastindex == 3:
-                email = m.group(3)
-            document.header[i] = "\\author %i %s %s" % (j, name, email)
-        j = j + 1
-        i = i + 1
+            email = m.group(3)
+            document.header[i] = "\\author %i %s %s" % (anum, name, email)
+        # FIXME Should this really be incremented if we didn't match?
+        anum += 1
+        i += 1
         
-    k = 0
+    i = 0
     while True:
-        k = find_token(document.body, "\\change_", k)
-        if k == -1:
+        i = find_token(document.body, "\\change_", i)
+        if i == -1:
             break
-
-        change = document.body[k].split(' ');
+        change = document.body[i].split(' ');
         if len(change) == 3:
             type = change[0]
             author_id = int(change[1])
             time = change[2]
-            document.body[k] = "%s %i %s" % (type, author_id + 1, time)
-        k = k + 1
+            document.body[i] = "%s %i %s" % (type, author_id + 1, time)
+        i += 1
+
 
 def revert_author_id(document):
     " Remove the author_id from the \\author definition "
     i = 0
-    j = 0
+    anum = 0
+    rx = re.compile(r'(\\author)\s+(\d+)\s+(\".*\")\s*(.*)$')
     idmap = dict()
+
     while True:
         i = find_token(document.header, "\\author", i)
         if i == -1:
             break
-        
-        r = re.compile(r'(\\author) (\d+) (\".*\")\s?(.*)$')
-        m = r.match(document.header[i])
-        if m != None:
+        m = rx.match(document.header[i])
+        if m:
             author_id = int(m.group(2))
-            idmap[author_id] = j
+            idmap[author_id] = anum
             name = m.group(3)
-            
-            email = ''
-            if m.lastindex == 4:
-                email = m.group(4)
+            email = m.group(4)
             document.header[i] = "\\author %s %s" % (name, email)
-        i = i + 1
-        j = j + 1
+        i += 1
+        # FIXME Should this be incremented if we didn't match?
+        anum += 1
 
-    k = 0
+    i = 0
     while True:
-        k = find_token(document.body, "\\change_", k)
-        if k == -1:
+        i = find_token(document.body, "\\change_", i)
+        if i == -1:
             break
-
-        change = document.body[k].split(' ');
+        change = document.body[i].split(' ');
         if len(change) == 3:
             type = change[0]
             author_id = int(change[1])
             time = change[2]
-            document.body[k] = "%s %i %s" % (type, idmap[author_id], time)
-        k = k + 1
+            document.body[i] = "%s %i %s" % (type, idmap[author_id], time)
+        i += 1
 
 
 def revert_suppress_date(document):
     " Revert suppressing of default document date to preamble code "
-    i = 0
-    while True:
-      i = find_token(document.header, "\\suppress_date", i)
-      if i == -1:
-          break
-      # remove the preamble line and write to the preamble
-      # when suppress_date was true
-      date = get_value(document.header, "\\suppress_date", i)
-      if date == "true":
-          add_to_preamble(document, ["% this command was inserted by lyx2lyx"])
-          add_to_preamble(document, ["\\date{}"])
-      del document.header[i]
-      i = i + 1
+    i = find_token(document.header, "\\suppress_date", 0)
+    if i == -1:
+        return
+    # remove the preamble line and write to the preamble
+    # when suppress_date was true
+    date = get_value(document.header, "\\suppress_date", i)
+    if date == "true":
+        add_to_preamble(document, ["% this command was inserted by lyx2lyx"])
+        add_to_preamble(document, ["\\date{}"])
+    del document.header[i]
 
 
 def revert_mhchem(document):
     "Revert mhchem loading to preamble code"
-    i = 0
-    j = 0
-    k = 0
+
     mhchem = "off"
-    i = find_token(document.header, "\\use_mhchem 1", 0)
-    if i != -1:
+    i = find_token(document.header, "\\use_mhchem", 0)
+    if i == -1:
+        document.warning("Malformed LyX document: Could not find mhchem setting.")
         mhchem = "auto"
     else:
-        i = find_token(document.header, "\\use_mhchem 2", 0)
-        if i != -1:
+        val = get_value(document.header, "\\use_mhchem", i)
+        if val == "1":
+            mhchem = "auto"
+        elif val == "2":
             mhchem = "on"
+        del document.header[i]
+
     if mhchem == "auto":
-        j = find_token(document.body, "\\cf{", 0)
-        if j != -1:
-            mhchem = "on"
-        else:
-            j = find_token(document.body, "\\ce{", 0)
-            if j != -1:
-                mhchem = "on"
+        i = 0
+        while True:
+            i = find_token(document.body, "\\begin_inset Formula", i)
+            if i == -1:
+               break
+            line = document.body[i]
+            if line.find("\\ce{") != -1 or line.find("\\cf{") != 1:
+              mhchem = "on"
+              break
+            i += 1
+
     if mhchem == "on":
-        add_to_preamble(document, ["% this command was inserted by lyx2lyx"])
-        add_to_preamble(document, ["\\PassOptionsToPackage{version=3}{mhchem}"])
-        add_to_preamble(document, ["\\usepackage{mhchem}"])
-    k = find_token(document.header, "\\use_mhchem", 0)
-    if k == -1:
-        document.warning("Malformed LyX document: Could not find mhchem setting.")
-        return
-    del document.header[k]
+        pre = ["% lyx2lyx mhchem commands", 
+          "\\PassOptionsToPackage{version=3}{mhchem}", 
+          "\\usepackage{mhchem}"]
+        add_to_preamble(document, pre) 
 
 
 def revert_fontenc(document):
@@ -1325,7 +931,7 @@ def revert_includeonly(document):
             return
         j = find_end_of(document.header, i, "\\begin_includeonly", "\\end_includeonly")
         if j == -1:
-            # this should not happen
+            document.warning("Unable to find end of includeonly section!!")
             break
         document.header[i : j + 1] = []
 
@@ -1338,7 +944,7 @@ def revert_includeall(document):
 
 
 def revert_multirow(document):
-    " Revert multirow cells in tables "
+    " Revert multirow cells in tables to TeX-code"
     i = 0
     multirow = False
     while True:
@@ -1350,33 +956,54 @@ def revert_multirow(document):
       multirow = True
       # remove the multirow tag, set the valignment to top
       # and remove the bottom line
+      # FIXME Are we sure these always have space around them?
       document.body[i] = document.body[i].replace(' multirow="3" ', ' ')
       document.body[i] = document.body[i].replace('valignment="middle"', 'valignment="top"')
       document.body[i] = document.body[i].replace(' bottomline="true" ', ' ')
       # write ERT to create the multirow cell
       # use 2 rows and 2cm as default with because the multirow span
       # and the column width is only hardly accessible
-      subst = [old_put_cmd_in_ert("\\multirow{2}{2cm}{")]
-      document.body[i + 4:i + 4] = subst
-      i = find_token(document.body, "</cell>", i)
-      if i == -1:
-           document.warning("Malformed LyX document: Could not find end of tabular cell.")
-           break
-      subst = [old_put_cmd_in_ert("}")]
-      document.body[i - 3:i - 3] = subst
-      # cell type 4 is multirow part cell
-      i = find_token(document.body, '<cell multirow="4"', i)
-      if i == -1:
-          break
-      # remove the multirow tag, set the valignment to top
-      # and remove the top line
-      document.body[i] = document.body[i].replace(' multirow="4" ', ' ')
-      document.body[i] = document.body[i].replace('valignment="middle"', 'valignment="top"')
-      document.body[i] = document.body[i].replace(' topline="true" ', ' ')
-      i = i + 1
+      cend = find_token(document.body, "</cell>", i)
+      if cend == -1:
+          document.warning("Malformed LyX document: Could not find end of tabular cell.")
+          i += 1
+          continue
+      blay = find_token(document.body, "\\begin_layout", i, cend)
+      if blay == -1:
+          document.warning("Can't find layout for cell!")
+          i = j
+          continue
+      bend = find_end_of_layout(document.body, blay)
+      if blay == -1:
+          document.warning("Can't find end of layout for cell!")
+          i = cend
+          continue
+
+      # do the later one first, so as not to mess up the numbering
+      # we are wrapping the whole cell in this ert
+      # so before the end of the layout...
+      document.body[bend:bend] = put_cmd_in_ert("}")
+      # ...and after the beginning
+      document.body[blay+1:blay+1] = put_cmd_in_ert("\\multirow{2}{2cm}{")
+
+      while True:
+          # cell type 4 is multirow part cell
+          k = find_token(document.body, '<cell multirow="4"', cend)
+          if k == -1:
+              break
+          # remove the multirow tag, set the valignment to top
+          # and remove the top line
+          # FIXME Are we sure these always have space around them?
+          document.body[k] = document.body[k].replace(' multirow="4" ', ' ')
+          document.body[k] = document.body[k].replace('valignment="middle"', 'valignment="top"')
+          document.body[k] = document.body[k].replace(' topline="true" ', ' ')
+          k += 1
+      # this will always be ok
+      i = cend
+
     if multirow == True:
-        add_to_preamble(document, ["% this command was inserted by lyx2lyx"])
-        add_to_preamble(document, ["\\usepackage{multirow}"])
+        add_to_preamble(document, 
+          ["% lyx2lyx multirow additions ", "\\usepackage{multirow}"])
 
 
 def convert_math_output(document):
@@ -1386,12 +1013,14 @@ def convert_math_output(document):
         return
     rgx = re.compile(r'\\html_use_mathml\s+(\w+)')
     m = rgx.match(document.header[i])
-    if rgx:
-        newval = "0" # MathML
-        val = m.group(1)
-        if val != "true":
-            newval = "2" # Images
-        document.header[i] = "\\html_math_output " + newval
+    newval = "0" # MathML
+    if m:
+      val = m.group(1)
+      if val != "true":
+        newval = "2" # Images
+    else:
+      document.warning("Can't match " + document.header[i])
+    document.header[i] = "\\html_math_output " + newval
 
 
 def revert_math_output(document):
@@ -1402,7 +1031,7 @@ def revert_math_output(document):
     rgx = re.compile(r'\\html_math_output\s+(\d)')
     m = rgx.match(document.header[i])
     newval = "true"
-    if rgx:
+    if m:
         val = m.group(1)
         if val == "1" or val == "2":
             newval = "false"
@@ -1415,45 +1044,89 @@ def revert_math_output(document):
 def revert_inset_preview(document):
     " Dissolves the preview inset "
     i = 0
-    j = 0
-    k = 0
     while True:
       i = find_token(document.body, "\\begin_inset Preview", i)
       if i == -1:
           return
-      j = find_end_of_inset(document.body, i)
-      if j == -1:
+      iend = find_end_of_inset(document.body, i)
+      if iend == -1:
           document.warning("Malformed LyX document: Could not find end of Preview inset.")
-          return
-      #If the layout is Standard we need to remove it, otherwise there
-      #will be paragraph breaks that shouldn't be there.
-      k = find_token(document.body, "\\begin_layout Standard", i)
-      if k == i + 2:
-          del document.body[i:i + 3]
-          del document.body[j - 5:j - 2]
-          i -= 6
-      else:
+          i += 1
+          continue
+      
+      # This has several issues.
+      # We need to do something about the layouts inside InsetPreview.
+      # If we just leave the first one, then we have something like:
+      # \begin_layout Standard
+      # ...
+      # \begin_layout Standard
+      # and we get a "no \end_layout" error. So something has to be done.
+      # Ideally, we would check if it is the same as the layout we are in.
+      # If so, we just remove it; if not, we end the active one. But it is 
+      # not easy to know what layout we are in, due to depth changes, etc,
+      # and it is not clear to me how much work it is worth doing. In most
+      # cases, the layout will probably be the same.
+      # 
+      # For the same reason, we have to remove the \end_layout tag at the
+      # end of the last layout in the inset. Again, that will sometimes be
+      # wrong, but it will usually be right. To know what to do, we would
+      # again have to know what layout the inset is in.
+      
+      blay = find_token(document.body, "\\begin_layout", i, iend)
+      if blay == -1:
+          document.warning("Can't find layout for preview inset!")
+          # always do the later one first...
+          del document.body[iend]
+          del document.body[i]
+          # deletions mean we do not need to reset i
+          continue
+
+      # This is where we would check what layout we are in.
+      # The check for Standard is definitely wrong.
+      # 
+      # lay = document.body[blay].split(None, 1)[1]
+      # if lay != oldlayout:
+      #     # record a boolean to tell us what to do later....
+      #     # better to do it later, since (a) it won't mess up
+      #     # the numbering and (b) we only modify at the end.
+        
+      # we want to delete the last \\end_layout in this inset, too.
+      # note that this may not be the \\end_layout that goes with blay!!
+      bend = find_end_of_layout(document.body, blay)
+      while True:
+          tmp = find_token(document.body, "\\end_layout", bend + 1, iend)
+          if tmp == -1:
+              break
+          bend = tmp
+      if bend == blay:
+          document.warning("Unable to find last layout in preview inset!")
+          del document.body[iend]
           del document.body[i]
-          del document.body[j - 1]
-          i -= 2
+          # deletions mean we do not need to reset i
+          continue
+      # always do the later one first...
+      del document.body[iend]
+      del document.body[bend]
+      del document.body[i:blay + 1]
+      # we do not need to reset i
                 
 
 def revert_equalspacing_xymatrix(document):
     " Revert a Formula with xymatrix@! to an ERT inset "
     i = 0
-    j = 0
     has_preamble = False
     has_equal_spacing = False
+
     while True:
-      found = -1
       i = find_token(document.body, "\\begin_inset Formula", i)
       if i == -1:
           break
       j = find_end_of_inset(document.body, i)
       if j == -1:
           document.warning("Malformed LyX document: Could not find end of Formula inset.")
-          break
-          
+          i += 1
+          continue
+      
       for curline in range(i,j):
           found = document.body[curline].find("\\xymatrix@!")
           if found != -1:
@@ -1465,7 +1138,7 @@ def revert_equalspacing_xymatrix(document):
           content += document.body[i + 1:j]
           subst = put_cmd_in_ert(content)
           document.body[i:j + 1] = subst
-          i += len(subst)
+          i += len(subst) - (j - i) + 1
       else:
           for curline in range(i,j):
               l = document.body[curline].find("\\xymatrix")
@@ -1473,134 +1146,96 @@ def revert_equalspacing_xymatrix(document):
                   has_preamble = True;
                   break;
           i = j + 1
+  
     if has_equal_spacing and not has_preamble:
-        add_to_preamble(document, ['\\usepackage[all]{xy}'])
+        add_to_preamble(document, ['% lyx2lyx xymatrix addition', '\\usepackage[all]{xy}'])
 
 
 def revert_notefontcolor(document):
     " Reverts greyed-out note font color to preamble code "
-    i = 0
-    colorcode = ""
-    while True:
-      i = find_token(document.header, "\\notefontcolor", i)
-      if i == -1:
-          return
-      colorcode = get_value(document.header, '\\notefontcolor', 0)
-      del document.header[i]
-      # the color code is in the form #rrggbb where every character denotes a hex number
-      # convert the string to an int
-      red = string.atoi(colorcode[1:3],16)
-      # we want the output "0.5" for the value "127" therefore increment here
-      if red != 0:
-          red = red + 1
-      redout = float(red) / 256
-      green = string.atoi(colorcode[3:5],16)
-      if green != 0:
-          green = green + 1
-      greenout = float(green) / 256
-      blue = string.atoi(colorcode[5:7],16)
-      if blue != 0:
-          blue = blue + 1
-      blueout = float(blue) / 256
-      # write the preamble
-      insert_to_preamble(0, document,
-                           '% Commands inserted by lyx2lyx to set the font color\n'
-                           '% for greyed-out notes\n'
-                           + '\\@ifundefined{definecolor}{\\usepackage{color}}{}\n'
-                           + '\\definecolor{note_fontcolor}{rgb}{'
-                           + str(redout) + ', ' + str(greenout)
-                           + ', ' + str(blueout) + '}\n'
-                           + '\\renewenvironment{lyxgreyedout}\n'
-                           + ' {\\textcolor{note_fontcolor}\\bgroup}{\\egroup}\n')
+
+    i = find_token(document.header, "\\notefontcolor", 0)
+    if i == -1:
+        return
+
+    # are there any grey notes?
+    if find_token(document.body, "\\begin_inset Note Greyedout", 0) == -1:
+        # no need to do anything, and \renewcommand will throw an error
+        # since lyxgreyedout will not exist.
+        return
+
+    colorcode = get_value(document.header, '\\notefontcolor', i)
+    del document.header[i]
+    # the color code is in the form #rrggbb where every character denotes a hex number
+    red = hex2ratio(colorcode[1:3])
+    green = hex2ratio(colorcode[3:5])
+    blue = hex2ratio(colorcode[5:7])
+    # write the preamble
+    insert_to_preamble(0, document,
+      ['% Commands inserted by lyx2lyx to set the font color',
+        '% for greyed-out notes',
+        '\\@ifundefined{definecolor}{\\usepackage{color}}{}'
+        '\\definecolor{note_fontcolor}{rgb}{%s,%s,%s}' % (red, green, blue),
+        '\\renewenvironment{lyxgreyedout}',
+        ' {\\textcolor{note_fontcolor}\\bgroup}{\\egroup}'])
 
 
 def revert_turkmen(document):
     "Set language Turkmen to English" 
-    i = 0 
+
     if document.language == "turkmen": 
         document.language = "english" 
         i = find_token(document.header, "\\language", 0) 
         if i != -1: 
             document.header[i] = "\\language english" 
+
     j = 0 
     while True: 
         j = find_token(document.body, "\\lang turkmen", j) 
         if j == -1: 
             return 
         document.body[j] = document.body[j].replace("\\lang turkmen", "\\lang english") 
-        j = j + 1 
+        j += 1 
 
 
 def revert_fontcolor(document):
     " Reverts font color to preamble code "
-    i = 0
-    colorcode = ""
-    while True:
-      i = find_token(document.header, "\\fontcolor", i)
-      if i == -1:
-          return
-      colorcode = get_value(document.header, '\\fontcolor', 0)
-      del document.header[i]
-      # don't clutter the preamble if backgroundcolor is not set
-      if colorcode == "#000000":
-          continue
-      # the color code is in the form #rrggbb where every character denotes a hex number
-      # convert the string to an int
-      red = string.atoi(colorcode[1:3],16)
-      # we want the output "0.5" for the value "127" therefore add here
-      if red != 0:
-          red = red + 1
-      redout = float(red) / 256
-      green = string.atoi(colorcode[3:5],16)
-      if green != 0:
-          green = green + 1
-      greenout = float(green) / 256
-      blue = string.atoi(colorcode[5:7],16)
-      if blue != 0:
-          blue = blue + 1
-      blueout = float(blue) / 256
-      # write the preamble
-      insert_to_preamble(0, document,
-                           '% Commands inserted by lyx2lyx to set the font color\n'
-                           + '\\@ifundefined{definecolor}{\\usepackage{color}}{}\n'
-                           + '\\definecolor{document_fontcolor}{rgb}{'
-                           + str(redout) + ', ' + str(greenout)
-                           + ', ' + str(blueout) + '}\n'
-                           + '\\color{document_fontcolor}\n')
+    i = find_token(document.header, "\\fontcolor", 0)
+    if i == -1:
+        return
+    colorcode = get_value(document.header, '\\fontcolor', i)
+    del document.header[i]
+    # don't clutter the preamble if font color is not set
+    if colorcode == "#000000":
+        return
+    # the color code is in the form #rrggbb where every character denotes a hex number
+    red = hex2ratio(colorcode[1:3])
+    green = hex2ratio(colorcode[3:5])
+    blue = hex2ratio(colorcode[5:7])
+    # write the preamble
+    insert_to_preamble(0, document,
+      ['% Commands inserted by lyx2lyx to set the font color',
+      '\\@ifundefined{definecolor}{\\usepackage{color}}{}',
+      '\\definecolor{document_fontcolor}{rgb}{%s,%s,%s}' % (red, green, blue),
+      '\\color{document_fontcolor}'])
+
 
 def revert_shadedboxcolor(document):
     " Reverts shaded box color to preamble code "
-    i = 0
-    colorcode = ""
-    while True:
-      i = find_token(document.header, "\\boxbgcolor", i)
-      if i == -1:
-          return
-      colorcode = get_value(document.header, '\\boxbgcolor', 0)
-      del document.header[i]
-      # the color code is in the form #rrggbb where every character denotes a hex number
-      # convert the string to an int
-      red = string.atoi(colorcode[1:3],16)
-      # we want the output "0.5" for the value "127" therefore increment here
-      if red != 0:
-          red = red + 1
-      redout = float(red) / 256
-      green = string.atoi(colorcode[3:5],16)
-      if green != 0:
-          green = green + 1
-      greenout = float(green) / 256
-      blue = string.atoi(colorcode[5:7],16)
-      if blue != 0:
-          blue = blue + 1
-      blueout = float(blue) / 256
-      # write the preamble
-      insert_to_preamble(0, document,
-                           '% Commands inserted by lyx2lyx to set the color\n'
-                           '% of boxes with shaded background\n'
-                           + '\\@ifundefined{definecolor}{\\usepackage{color}}{}\n'
-                           + '\\definecolor{shadecolor}{rgb}{'
-                           + str(redout) + ', ' + str(greenout)
-                           + ', ' + str(blueout) + '}\n')
+    i = find_token(document.header, "\\boxbgcolor", 0)
+    if i == -1:
+        return
+    colorcode = get_value(document.header, '\\boxbgcolor', i)
+    del document.header[i]
+    # the color code is in the form #rrggbb
+    red = hex2ratio(colorcode[1:3])
+    green = hex2ratio(colorcode[3:5])
+    blue = hex2ratio(colorcode[5:7])
+    # write the preamble
+    insert_to_preamble(0, document,
+      ['% Commands inserted by lyx2lyx to set the color of boxes with shaded background',
+      '\\@ifundefined{definecolor}{\\usepackage{color}}{}',
+      "\\definecolor{shadecolor}{rgb}{%s,%s,%s}" % (red, green, blue)])
 
 
 def revert_lyx_version(document):
@@ -1619,8 +1254,10 @@ def revert_lyx_version(document):
             return
         j = find_end_of_inset(document.body, i + 1)
         if j == -1:
-            # should not happen
             document.warning("Malformed LyX document: Could not find end of Info inset.")
+            i += 1
+            continue
+
         # We expect:
         # \begin_inset Info
         # type  "lyxinfo"
@@ -1891,8 +1528,7 @@ def revert_makebox(document):
       length = document.body[l][7:]
       # remove trailing '"'
       length = length[:-1]
-      # latex_length returns "bool,length"
-      length = latex_length(length).split(",")[1]
+      length = latex_length(length)[1]
       subst = "\\makebox[" + length + "][" \
         + align + "]{"
       document.body[i:y + 1] = put_cmd_in_ert(subst)
@@ -1960,6 +1596,52 @@ def revert_IEEEtran(document):
           del document.body[i:j + 1]
 
 
+def convert_prettyref(document):
+	" Converts prettyref references to neutral formatted refs "
+	re_ref = re.compile("^\s*reference\s+\"(\w+):(\S+)\"")
+	nm_ref = re.compile("^\s*name\s+\"(\w+):(\S+)\"")
+
+	i = 0
+	while True:
+		i = find_token(document.body, "\\begin_inset CommandInset ref", i)
+		if i == -1:
+			break
+		j = find_end_of_inset(document.body, i)
+		if j == -1:
+			document.warning("Malformed LyX document: No end of InsetRef!")
+			i += 1
+			continue
+		k = find_token(document.body, "LatexCommand prettyref", i)
+		if k != -1 and k < j:
+			document.body[k] = "LatexCommand formatted"
+		i = j + 1
+	document.header.insert(-1, "\\use_refstyle 0")
+		
+ 
+def revert_refstyle(document):
+	" Reverts neutral formatted refs to prettyref "
+	re_ref = re.compile("^reference\s+\"(\w+):(\S+)\"")
+	nm_ref = re.compile("^\s*name\s+\"(\w+):(\S+)\"")
+
+	i = 0
+	while True:
+		i = find_token(document.body, "\\begin_inset CommandInset ref", i)
+		if i == -1:
+			break
+		j = find_end_of_inset(document.body, i)
+		if j == -1:
+			document.warning("Malformed LyX document: No end of InsetRef")
+			i += 1
+			continue
+		k = find_token(document.body, "LatexCommand formatted", i)
+		if k != -1 and k < j:
+			document.body[k] = "LatexCommand prettyref"
+		i = j + 1
+	i = find_token(document.header, "\\use_refstyle", 0)
+	if i != -1:
+		document.header.pop(i)
+ 
+
 def revert_nameref(document):
   " Convert namerefs to regular references "
   cmds = ["Nameref", "nameref"]
@@ -2056,6 +1738,110 @@ def revert_mathrsfs(document):
       i += 1
 
 
+def convert_flexnames(document):
+    "Convert \\begin_inset Flex Custom:Style to \\begin_inset Flex Style and similarly for CharStyle and Element."
+    
+    i = 0
+    rx = re.compile(r'^\\begin_inset Flex (?:Custom|CharStyle|Element):(.+)$')
+    while True:
+      i = find_token(document.body, "\\begin_inset Flex", i)
+      if i == -1:
+        return
+      m = rx.match(document.body[i])
+      if m:
+        document.body[i] = "\\begin_inset Flex " + m.group(1)
+      i += 1
+
+
+flex_insets = [
+  ["Alert", "CharStyle:Alert"],
+  ["Code", "CharStyle:Code"],
+  ["Concepts", "CharStyle:Concepts"],
+  ["E-Mail", "CharStyle:E-Mail"],
+  ["Emph", "CharStyle:Emph"],
+  ["Expression", "CharStyle:Expression"],
+  ["Initial", "CharStyle:Initial"],
+  ["Institute", "CharStyle:Institute"],
+  ["Meaning", "CharStyle:Meaning"],
+  ["Noun", "CharStyle:Noun"],
+  ["Strong", "CharStyle:Strong"],
+  ["Structure", "CharStyle:Structure"],
+  ["ArticleMode", "Custom:ArticleMode"],
+  ["Endnote", "Custom:Endnote"],
+  ["Glosse", "Custom:Glosse"],
+  ["PresentationMode", "Custom:PresentationMode"],
+  ["Tri-Glosse", "Custom:Tri-Glosse"]
+]
+
+flex_elements = [
+  ["Abbrev", "Element:Abbrev"],
+  ["CCC-Code", "Element:CCC-Code"],
+  ["Citation-number", "Element:Citation-number"],
+  ["City", "Element:City"],
+  ["Code", "Element:Code"],
+  ["CODEN", "Element:CODEN"],
+  ["Country", "Element:Country"],
+  ["Day", "Element:Day"],
+  ["Directory", "Element:Directory"],
+  ["Dscr", "Element:Dscr"],
+  ["Email", "Element:Email"],
+  ["Emph", "Element:Emph"],
+  ["Filename", "Element:Filename"],
+  ["Firstname", "Element:Firstname"],
+  ["Fname", "Element:Fname"],
+  ["GuiButton", "Element:GuiButton"],
+  ["GuiMenu", "Element:GuiMenu"],
+  ["GuiMenuItem", "Element:GuiMenuItem"],
+  ["ISSN", "Element:ISSN"],
+  ["Issue-day", "Element:Issue-day"],
+  ["Issue-months", "Element:Issue-months"],
+  ["Issue-number", "Element:Issue-number"],
+  ["KeyCap", "Element:KeyCap"],
+  ["KeyCombo", "Element:KeyCombo"],
+  ["Keyword", "Element:Keyword"],
+  ["Literal", "Element:Literal"],
+  ["MenuChoice", "Element:MenuChoice"],
+  ["Month", "Element:Month"],
+  ["Orgdiv", "Element:Orgdiv"],
+  ["Orgname", "Element:Orgname"],
+  ["Postcode", "Element:Postcode"],
+  ["SS-Code", "Element:SS-Code"],
+  ["SS-Title", "Element:SS-Title"],
+  ["State", "Element:State"],
+  ["Street", "Element:Street"],
+  ["Surname", "Element:Surname"],
+  ["Volume", "Element:Volume"],
+  ["Year", "Element:Year"]
+]
+
+
+def revert_flexnames(document):
+  if document.backend == "latex":
+    flexlist = flex_insets
+  else:
+    flexlist = flex_elements
+  
+  rx = re.compile(r'^\\begin_inset Flex\s+(.+)$')
+  i = 0
+  while True:
+    i = find_token(document.body, "\\begin_inset Flex", i)
+    if i == -1:
+      return
+    m = rx.match(document.body[i])
+    if not m:
+      document.warning("Illegal flex inset: " + document.body[i])
+      i += 1
+      continue
+    
+    style = m.group(1)
+    for f in flexlist:
+      if f[0] == style:
+        document.body[i] = "\\begin_inset Flex " + f[1]
+        break
+
+    i += 1
+
+
 def convert_mathdots(document):
     " Load mathdots automatically "
     while True:
@@ -2067,14 +1853,34 @@ def convert_mathdots(document):
 
 def revert_mathdots(document):
     " Load mathdots if used in the document "
+    i = 0
+    ddots = re.compile(r'\\begin_inset Formula .*\\ddots', re.DOTALL)
+    vdots = re.compile(r'\\begin_inset Formula .*\\vdots', re.DOTALL)
+    iddots = re.compile(r'\\begin_inset Formula .*\\iddots', re.DOTALL)
+    mathdots = find_token(document.header, "\\use_mathdots" , 0)
+    no = find_token(document.header, "\\use_mathdots 0" , 0)
+    auto = find_token(document.header, "\\use_mathdots 1" , 0)
+    yes = find_token(document.header, "\\use_mathdots 2" , 0)
+    if mathdots != -1:
+      del document.header[mathdots]
     while True:
-      i = find_token(document.header, "\\use_mathdots" , 0)
-      if i != -1:
-        # use \@ifundefined to catch also the "auto" case
-        add_to_preamble(document, ["% this command was inserted by lyx2lyx"])
-        add_to_preamble(document, ["\\@ifundefined{iddots}{\\usepackage{mathdots}}\n"])
-        del document.header[i]
-      break
+      i = find_token(document.body, '\\begin_inset Formula', i)
+      if i == -1:
+        return
+      j = find_end_of_inset(document.body, i)
+      if j == -1:
+        document.warning("Malformed LyX document: Can't find end of Formula inset.")
+        return 
+      k = ddots.search("\n".join(document.body[i:j]))
+      l = vdots.search("\n".join(document.body[i:j]))
+      m = iddots.search("\n".join(document.body[i:j]))
+      if (yes == -1) and ((no != -1) or (not k and not l and not m) or (auto != -1 and not m)):
+        i += 1
+        continue
+      # use \@ifundefined to catch also the "auto" case
+      add_to_preamble(document, ["% this command was inserted by lyx2lyx"])
+      add_to_preamble(document, ["\\@ifundefined{iddots}{\\usepackage{mathdots}}\n"])
+      return
 
 
 def convert_rule(document):
@@ -2082,44 +1888,44 @@ def convert_rule(document):
     i = 0
     while True:
       i = find_token(document.body, "\\lyxline" , i)
-      if i != -1:
-        j = find_token(document.body, "\\color" , i - 2)
-        if j == i - 2:
-          color = document.body[j] + '\n'
-        else:
-          color = ''
-        k = find_token(document.body, "\\begin_layout Standard" , i - 4)
-        # we need to handle the case that \lyxline is in a separate paragraph and that it is colored
-        # the result is then an extra empty paragraph which we get by adding an empty ERT inset
-        if k == i - 4 and j == i - 2 and document.body[i - 1] == '':
-          layout = '\\begin_inset ERT\nstatus collapsed\n\n\\begin_layout Plain Layout\n\n\n\\end_layout\n\n\\end_inset\n' \
-            + '\\end_layout\n\n' \
-            + '\\begin_layout Standard\n'
-        elif k == i - 2 and document.body[i - 1] == '':
-          layout = ''
-        else:
-          layout = '\\end_layout\n\n' \
-            + '\\begin_layout Standard\n'
-        l = find_token(document.body, "\\begin_layout Standard" , i + 4)
-        if l == i + 4 and document.body[i + 1] == '':
-          layout2 = ''
-        else:
-          layout2 = '\\end_layout\n' \
-            + '\n\\begin_layout Standard\n'
-        subst = layout \
-          + '\\noindent\n\n' \
-          + color \
-          + '\\begin_inset CommandInset line\n' \
-          + 'LatexCommand rule\n' \
-          + 'offset "0.5ex"\n' \
-          + 'width "100line%"\n' \
-          + 'height "1pt"\n' \
-          + '\n\\end_inset\n\n\n' \
-          + layout2
-        document.body[i] = subst
-        i += 1
-      else:
+      if i == -1:
         return
+        
+      j = find_token(document.body, "\\color" , i - 2)
+      if j == i - 2:
+        color = document.body[j] + '\n'
+      else:
+        color = ''
+      k = find_token(document.body, "\\begin_layout Standard" , i - 4)
+      # we need to handle the case that \lyxline is in a separate paragraph and that it is colored
+      # the result is then an extra empty paragraph which we get by adding an empty ERT inset
+      if k == i - 4 and j == i - 2 and document.body[i - 1] == '':
+        layout = '\\begin_inset ERT\nstatus collapsed\n\n\\begin_layout Plain Layout\n\n\n\\end_layout\n\n\\end_inset\n' \
+          + '\\end_layout\n\n' \
+          + '\\begin_layout Standard\n'
+      elif k == i - 2 and document.body[i - 1] == '':
+        layout = ''
+      else:
+        layout = '\\end_layout\n\n' \
+          + '\\begin_layout Standard\n'
+      l = find_token(document.body, "\\begin_layout Standard" , i + 4)
+      if l == i + 4 and document.body[i + 1] == '':
+        layout2 = ''
+      else:
+        layout2 = '\\end_layout\n' \
+          + '\n\\begin_layout Standard\n'
+      subst = layout \
+        + '\\noindent\n\n' \
+        + color \
+        + '\\begin_inset CommandInset line\n' \
+        + 'LatexCommand rule\n' \
+        + 'offset "0.5ex"\n' \
+        + 'width "100line%"\n' \
+        + 'height "1pt"\n' \
+        + '\n\\end_inset\n\n\n' \
+        + layout2
+      document.body[i] = subst
+      i += 1
 
 
 def revert_rule(document):
@@ -2127,40 +1933,43 @@ def revert_rule(document):
     i = 0
     while 1:
       i = find_token(document.body, "\\begin_inset CommandInset line" , i)
-      if i != -1:
-        # find end of inset
-        j = find_token(document.body, "\\end_inset" , i)
-        # assure we found the end_inset of the current inset
-        if j > i + 6 or j == -1:
-          document.warning("Malformed LyX document: Can't find end of line inset.")
-          return
-        # determine the optional offset
-        k = find_token(document.body, 'offset', i)
-        if k != -1 and k < j:
-          offset = document.body[k][8:]
-        else:
-          offset = '0"'
-        # determine the width
-        l = find_token(document.body, 'width', k + 1)
-        width = document.body[l][7:]
-        # determine the height
-        m = find_token(document.body, 'height', l + 1)
-        height = document.body[m][8:]
-        # remove trailing '"'
-        offset = offset[:-1]
-        width = width[:-1]
-        height = height[:-1]
-        # output the \rule command
-        if offset <> "0":
-          subst = "\\rule[" + offset + "]{" + width + "}{" + height + "}"
-        else:
-          subst = "\\rule{" + width + "}{" + height + "}"
-        document.body[i:j + 1] = put_cmd_in_ert(subst)
-        i += 1
-      else:
+      if i == -1:
+        return
+      # find end of inset
+      j = find_token(document.body, "\\end_inset" , i)
+      # assure we found the end_inset of the current inset
+      if j > i + 6 or j == -1:
+        document.warning("Malformed LyX document: Can't find end of line inset.")
         return
+      # determine the optional offset
+      k = find_token(document.body, 'offset', i, j)
+      if k != -1:
+        offset = document.body[k][8:-1]
+      else:
+        offset = ""
+      # determine the width
+      l = find_token(document.body, 'width', i, j)
+      if l != -1:
+        width = document.body[l][7:-1]
+      else:
+        width = "100col%"
+      # determine the height
+      m = find_token(document.body, 'height', i, j)
+      if m != -1:
+        height = document.body[m][8:-1]
+      else:
+        height = "1pt"
+      # output the \rule command
+      if offset:
+        subst = "\\rule[" + offset + "]{" + width + "}{" + height + "}"
+      else:
+        subst = "\\rule{" + width + "}{" + height + "}"
+      document.body[i:j + 1] = put_cmd_in_ert(subst)
+      i += 1
+
 
 def revert_diagram(document):
+  " Add the feyn package if \\Diagram is used in math "
   i = 0
   re_diagram = re.compile(r'\\begin_inset Formula .*\\Diagram', re.DOTALL)
   while True:
@@ -2169,17 +1978,82 @@ def revert_diagram(document):
       return
     j = find_end_of_inset(document.body, i)
     if j == -1:
-        document.warning("Malformed LyX document: Can't find end of line inset.")
+        document.warning("Malformed LyX document: Can't find end of Formula inset.")
         return 
     m = re_diagram.search("\n".join(document.body[i:j]))
     if not m:
       i += 1
       continue
-    add_to_preamble(document, "\\use_package{feyn}")
+    add_to_preamble(document, ["% this command was inserted by lyx2lyx"])
+    add_to_preamble(document, "\\usepackage{feyn}")
     # only need to do it once!
     return
 
 
+def convert_bibtex_clearpage(document):
+  " insert a clear(double)page bibliographystyle if bibtotoc option is used "
+
+  i = find_token(document.header, '\\papersides', 0)
+  if i == -1:
+    document.warning("Malformed LyX document: Can't find papersides definition.")
+    return
+  sides = int(document.header[i][12])
+
+  j = 0
+  while True:
+    j = find_token(document.body, "\\begin_inset CommandInset bibtex", j)
+    if j == -1:
+      return
+
+    k = find_end_of_inset(document.body, j)
+    if k == -1:
+      document.warning("Can't find end of Bibliography inset at line " + str(j))
+      j += 1
+      continue
+
+    # only act if there is the option "bibtotoc"
+    m = find_token(document.body, 'options', j, k)
+    if m == -1:
+      document.warning("Can't find options for bibliography inset at line " + str(j))
+      j = k
+      continue
+    
+    optline = document.body[m]
+    idx = optline.find("bibtotoc")
+    if idx == -1:
+      j = k
+      continue
+    
+    # so we want to insert a new page right before the paragraph that
+    # this bibliography thing is in. we'll look for it backwards.
+    lay = j - 1
+    while lay >= 0:
+      if document.body[lay].startswith("\\begin_layout"):
+        break
+      lay -= 1
+
+    if lay < 0:
+      document.warning("Can't find layout containing bibliography inset at line " + str(j))
+      j = k
+      continue
+
+    subst1 = '\\begin_layout Standard\n' \
+      + '\\begin_inset Newpage clearpage\n' \
+      + '\\end_inset\n\n\n' \
+      + '\\end_layout\n'
+    subst2 = '\\begin_layout Standard\n' \
+      + '\\begin_inset Newpage cleardoublepage\n' \
+      + '\\end_inset\n\n\n' \
+      + '\\end_layout\n'
+    if sides == 1:
+      document.body.insert(lay, subst1)
+      document.warning(subst1)
+    else:
+      document.body.insert(lay, subst2)
+      document.warning(subst2)
+
+    j = k
+
 
 ##
 # Conversion hub
@@ -2232,7 +2106,7 @@ convert = [[346, []],
            [389, [convert_html_quotes]],
            [390, []],
            [391, []],
-           [392, [convert_beamer_args]],
+           [392, []],
            [393, [convert_optarg]],
            [394, [convert_use_makebox]],
            [395, []],
@@ -2241,10 +2115,16 @@ convert = [[346, []],
            [398, []],
            [399, [convert_mathdots]],
            [400, [convert_rule]],
-           [401, []]
-          ]
-
-revert =  [[400, [revert_diagram]],
+           [401, []],
+           [402, [convert_bibtex_clearpage]],
+           [403, [convert_flexnames]],
+           [404, [convert_prettyref]]
+]
+
+revert =  [[403, [revert_refstyle]],
+           [402, [revert_flexnames]],
+           [401, []],
+           [400, [revert_diagram]],
            [399, [revert_rule]],
            [398, [revert_mathdots]],
            [397, [revert_mathrsfs]],