X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=lib%2Flyx2lyx%2Flyx_2_1.py;h=af9f1e6d76c2edf59dc51d9ba7673f46e1523b7b;hb=f88986eff5aedf6cce5832b0f5028124e72482a4;hp=f97e6be58c41208289287dd30029259cc02d3bb6;hpb=e28625160a5078ffb37fc27ad3906edf5a73a31f;p=lyx.git

diff --git a/lib/lyx2lyx/lyx_2_1.py b/lib/lyx2lyx/lyx_2_1.py
index f97e6be58c..af9f1e6d76 100644
--- a/lib/lyx2lyx/lyx_2_1.py
+++ b/lib/lyx2lyx/lyx_2_1.py
@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 # This file is part of lyx2lyx
-# -*- coding: utf-8 -*-
 # Copyright (C) 2011 The LyX team
 #
 # This program is free software; you can redistribute it and/or
@@ -25,16 +24,17 @@ import sys, os
 
 # Uncomment only what you need to import, please.
 
-from parser_tools import count_pars_in_inset, del_token, find_token, find_token_exact, \
+from parser_tools import count_pars_in_inset, del_complete_lines, del_token, \
+    find_token, find_token_exact, \
     find_token_backwards, find_end_of, find_end_of_inset, find_end_of_layout, \
     find_end_of_sequence, find_re, get_option_value, get_containing_layout, \
-    get_value, get_quoted_value, set_option_value
+    get_containing_inset, get_value, get_quoted_value, set_option_value
 
 #from parser_tools import find_token, find_end_of, find_tokens, \
   #find_end_of_inset, find_end_of_layout, \
   #is_in_inset, del_token, check_token
 
-from lyx2lyx_tools import add_to_preamble, put_cmd_in_ert, get_ert
+from lyx2lyx_tools import add_to_preamble, put_cmd_in_ert, get_ert, revert_language
 
 #from lyx2lyx_tools import insert_to_preamble, \
 #  lyx2latex, latex_length, revert_flex_inset, \
@@ -53,6 +53,219 @@ from lyx2lyx_tools import add_to_preamble, put_cmd_in_ert, get_ert
     #return True
 
 
+def revert_Argument_to_TeX_brace(document, line, endline, n, nmax, environment, opt):
+    '''
+    Reverts an InsetArgument to TeX-code
+    usage:
+    revert_Argument_to_TeX_brace(document, LineOfBegin, LineOfEnd, StartArgument, EndArgument, isEnvironment, isOpt)
+    LineOfBegin is the line  of the \\begin_layout or \\begin_inset statement
+    LineOfEnd is the line  of the \\end_layout or \\end_inset statement, if "0" is given, the end of the file is used instead
+    StartArgument is the number of the first argument that needs to be converted
+    EndArgument is the number of the last argument that needs to be converted or the last defined one
+    isEnvironment must be true, if the layout is for a LaTeX environment
+    isOpt must be true, if the argument is an optional one
+    '''
+    lineArg = 0
+    wasOpt = False
+    while lineArg != -1 and n < nmax + 1:
+      lineArg = find_token(document.body, "\\begin_inset Argument " + str(n), line)
+      if lineArg > endline and endline != 0:
+        return wasOpt
+      if lineArg != -1:
+        beginPlain = find_token(document.body, "\\begin_layout Plain Layout", lineArg)
+        # we have to assure that no other inset is in the Argument
+        beginInset = find_token(document.body, "\\begin_inset", beginPlain)
+        endInset = find_token(document.body, "\\end_inset", beginPlain)
+        k = beginPlain + 1
+        l = k
+        while beginInset < endInset and beginInset != -1:
+          beginInset = find_token(document.body, "\\begin_inset", k)
+          endInset = find_token(document.body, "\\end_inset", l)
+          k = beginInset + 1
+          l = endInset + 1
+        if environment == False:
+          if opt == False:
+            document.body[endInset - 2 : endInset + 1] = put_cmd_in_ert("}{")
+            del(document.body[lineArg : beginPlain + 1])
+            wasOpt = False
+          else:
+            document.body[endInset - 2 : endInset + 1] = put_cmd_in_ert("]")
+            document.body[lineArg : beginPlain + 1] = put_cmd_in_ert("[")
+            wasOpt = True
+        else:
+          document.body[endInset - 2 : endInset + 1] = put_cmd_in_ert("}")
+          document.body[lineArg : beginPlain + 1] = put_cmd_in_ert("{")
+          wasOpt = False
+        n += 1
+    return wasOpt
+
+
+def convert_TeX_brace_to_Argument(document, line, n, nmax, inset, environment, opt):
+    '''
+    Converts TeX code for mandatory arguments to an InsetArgument
+    The conversion of TeX code for optional arguments must be done with another routine
+    !!! Be careful if the braces are different in your case as expected here:
+    - "}{" separates mandatory arguments of commands
+    - "}" + "{" separates mandatory arguments of commands
+    - "}" + " " + "{" separates mandatory arguments of commands
+    - { and } surround a mandatory argument of an environment
+    usage:
+    convert_TeX_brace_to_Argument(document, LineOfBeginLayout/Inset, StartArgument, EndArgument, isInset, isEnvironment, isOpt)
+    LineOfBeginLayout/Inset is the line  of the \\begin_layout or \\begin_inset statement
+    StartArgument is the number of the first ERT that needs to be converted
+    EndArgument is the number of the last ERT that needs to be converted
+    isInset must be true, if braces inside an InsetLayout needs to be converted
+    isEnvironment must be true, if the layout is for a LaTeX environment
+    isOpt must be true, if the argument is an optional one
+
+    Todo: this routine can currently handle only one mandatory argument of environments
+    '''
+
+    end_layout = find_end_of_layout(document.body, line)
+    lineERT = line
+    endn = line
+    loop = 1
+    while n < nmax + 1:
+      lineERT = find_token(document.body, "\\begin_inset ERT", lineERT, end_layout)
+      if lineERT == -1:
+        break
+      if environment == False:
+        end_ERT = find_end_of_inset(document.body, lineERT)
+        if end_ERT == -1:
+          document.warning("Can't find end of ERT!!")
+          break
+        # Note that this only checks for ][ or }{ at the beginning of a line
+        if opt:
+          bracePair = find_token(document.body, "][", lineERT, end_ERT)
+        else:
+          bracePair = find_token(document.body, "}{", lineERT, end_ERT)
+        if bracePair != -1:
+          end = find_token(document.body, "\\end_inset", bracePair)
+          document.body[lineERT : end_ERT + 1] = ["\\end_layout", "", "\\end_inset"]
+          if loop == 1:
+            # in the case that n > 1 we have optional arguments before
+            # therefore detect them if any
+            if n > 1:
+              # first check if there is an argument
+              lineArg = find_token(document.body, "\\begin_inset Argument", line)
+              if lineArg < lineERT and lineArg != -1:
+                # we have an argument, so now search backwards for its end
+                # we must now assure that we don't find other insets like e.g. a newline
+                endInsetArg = lineERT
+                endLayoutArg = endInsetArg
+                while endInsetArg != endLayoutArg + 2 and endInsetArg != -1:
+                  endInsetArg = endInsetArg - 1
+                  endLayoutArg = endInsetArg
+                  endInsetArg = find_token_backwards(document.body, "\\end_inset", endInsetArg)
+                  endLayoutArg = find_token_backwards(document.body, "\\end_layout", endLayoutArg)
+                line = endInsetArg + 1
+            if inset == False:
+              document.body[line + 1 : line + 1] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
+            else:
+              document.body[line + 4 : line + 4] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
+          else: # if loop != 1
+            document.body[endn : endn] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
+          n += 1
+          endn = end
+          loop += 1
+        else:
+          # no brace pair found
+          # now check the case that we have "}" + "{" in two ERTs
+          if opt:
+            endBrace = find_token(document.body, "]", lineERT, end_layout)
+          else:
+            endBrace = find_token(document.body, "}", lineERT, end_layout)
+          if endBrace == lineERT + 5:
+            if opt:
+              beginBrace = find_token(document.body, "[", endBrace, end_layout)
+            else:
+              beginBrace = find_token(document.body, "{", endBrace, end_layout)
+            # assure that the ERTs are consecutive (11 or 12 depending if there is a space between the ERTs or not)
+            if beginBrace != -1 and (beginBrace == endBrace + 11 or beginBrace == endBrace + 12):
+              end = find_token(document.body, "\\end_inset", beginBrace)
+              document.body[lineERT : end + 1] = ["\\end_layout", "", "\\end_inset"]
+              if loop == 1:
+                # in the case that n > 1 we have optional arguments before
+                # therefore detect them if any
+                if n > 1:
+                  # first check if there is an argument
+                  lineArg = find_token(document.body, "\\begin_inset Argument", line)
+                  if lineArg < lineERT and lineArg != -1:
+                    # we have an argument, so now search backwards for its end
+                    # we must now assure that we don't find other insets like e.g. a newline
+                    endInsetArg = lineERT
+                    endLayoutArg = endInsetArg
+                    while endInsetArg != endLayoutArg + 2 and endInsetArg != -1:
+                      endInsetArg = endInsetArg - 1
+                      endLayoutArg = endInsetArg
+                      endInsetArg = find_token_backwards(document.body, "\\end_inset", endInsetArg)
+                      endLayoutArg = find_token_backwards(document.body, "\\end_layout", endLayoutArg)
+                    line = endInsetArg + 1
+                if inset == False:
+                  document.body[line + 1 : line + 1] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
+                else:
+                  document.body[line + 4 : line + 4] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
+              else:
+                document.body[endn : endn] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
+              n += 1
+              loop += 1
+              # set the line where the next argument will be inserted
+              if beginBrace == endBrace + 11:
+                endn = end - 11
+              else:
+                endn = end - 12
+            else:
+              lineERT += 1
+          else:
+            lineERT += 1
+      if environment == True:
+        # FIXME This version of the routine does not check for and pass over
+        # arguments before n. So it attempts to process the argument in the
+        # document, no matter what has been specified.
+        #
+        # The other branch does do that, but probably that code would be better
+        # in a single location: Skip all those arguments, then process the ones
+        # we want.
+        end_ERT = find_end_of_inset(document.body, lineERT)
+        if end_ERT == -1:
+          document.warning("Can't find end of ERT!!")
+          break
+        # Note that this only checks for [ or { at the beginning of a line
+        if opt:
+          opening = find_token(document.body, "[", lineERT, end_ERT)
+        else:
+          opening = find_token(document.body, "{", lineERT, end_ERT)
+        if opening != -1:
+          lineERT2 = find_token(document.body, "\\begin_inset ERT", end_ERT, end_layout)
+          if lineERT2 == -1:
+            # argument in a single ERT
+            # strip off the opening bracket
+            document.body[opening] = document.body[opening][1:]
+            ertcontlastline = end_ERT - 3
+            if (opt and document.body[ertcontlastline].endswith("]")) or document.body[ertcontlastline].endswith("}"):
+              # strip off the closing bracket
+              document.body[ertcontlastline] = document.body[ertcontlastline][:-1]
+              end2 = find_token(document.body, "\\end_inset", ertcontlastline)
+              document.body[lineERT : lineERT + 1] = ["\\begin_inset Argument " + str(n)]
+          else:
+            end_ERT2 = find_end_of_inset(document.body, lineERT2)
+            if end_ERT2 == -1:
+              document.warning("Can't find end of second ERT!!")
+              break
+            if opt:
+              closing = find_token(document.body, "]", lineERT2, end_ERT2)
+            else:
+              closing = find_token(document.body, "}", lineERT2, end_ERT2)
+            if closing != -1: # assure that the "}" is in this ERT
+              end2 = find_token(document.body, "\\end_inset", closing)
+              document.body[lineERT2 : end2 + 1] = ["\\end_layout", "", "\\end_inset"]
+            document.body[lineERT : end_ERT + 1] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
+          n += 1
+        else:
+          document.warning("Unable to process argument!")
+          n += 1
+
+
 ###############################################################################
 ###
 ### Conversion and reversion routines
@@ -71,6 +284,7 @@ def revert_visible_space(document):
       document.body[i:end + 1] = subst
 
 
+undertilde_commands = ["utilde"]
 def convert_undertilde(document):
     " Load undertilde automatically "
     i = find_token(document.header, "\\use_mathdots" , 0)
@@ -82,56 +296,64 @@ def convert_undertilde(document):
         document.warning("Malformed LyX document: Can't find \\use_mathdots.")
         return;
     j = find_token(document.preamble, "\\usepackage{undertilde}", 0)
-    if j == -1:
-        document.header.insert(i + 1, "\\use_undertilde 0")
-    else:
-        document.header.insert(i + 1, "\\use_undertilde 2")
+    if j != -1:
+        # package was loaded in the preamble, convert this to header setting for round trip
+        document.header.insert(i + 1, "\\use_undertilde 2") # on
         del document.preamble[j]
+    else:
+        j = 0
+        while True:
+            j = find_token(document.body, '\\begin_inset Formula', j)
+            if j == -1:
+                break
+            k = find_end_of_inset(document.body, j)
+            if k == -1:
+                document.warning("Malformed LyX document: Can't find end of Formula inset at line " + str(j))
+                j += 1
+                continue
+            code = "\n".join(document.body[j:k])
+            for c in undertilde_commands:
+                if code.find("\\%s" % c) != -1:
+                    # at least one of the commands was found - need to switch package off
+                    document.header.insert(i + 1, "\\use_undertilde 0") # off
+                    return
+            j = k
+        # no command was found - set to auto (bug 9069)
+        document.header.insert(i + 1, "\\use_undertilde 1") # auto
+
 
 
 def revert_undertilde(document):
     " Load undertilde if used in the document "
-    undertilde = find_token(document.header, "\\use_undertilde" , 0)
-    if undertilde == -1:
-      document.warning("No \\use_undertilde line. Assuming auto.")
-    else:
-      val = get_value(document.header, "\\use_undertilde", undertilde)
-      del document.header[undertilde]
-      try:
-        usetilde = int(val)
-      except:
-        document.warning("Invalid \\use_undertilde value: " + val + ". Assuming auto.")
-        # probably usedots has not been changed, but be safe.
-        usetilde = 1
-
-      if usetilde == 0:
-        # do not load case
-        return
-      if usetilde == 2:
-        # force load case
+    regexp = re.compile(r'(\\use_undertilde)')
+    i = find_re(document.header, regexp, 0)
+    value = "1" # default is auto
+    if i != -1:
+        value = get_value(document.header, "\\use_undertilde" , i).split()[0]
+        del document.header[i]
+    if value == "2": # on
         add_to_preamble(document, ["\\usepackage{undertilde}"])
-        return
-
-    # so we are in the auto case. we want to load undertilde if \utilde is used.
-    i = 0
-    while True:
-      i = find_token(document.body, '\\begin_inset Formula', i)
-      if i == -1:
-        return
-      j = find_end_of_inset(document.body, i)
-      if j == -1:
-        document.warning("Malformed LyX document: Can't find end of Formula inset at line " + str(i))
-        i += 1
-        continue
-      code = "\n".join(document.body[i:j])
-      if code.find("\\utilde") != -1:
-        add_to_preamble(document, ["\\@ifundefined{utilde}{\\usepackage{undertilde}}"])
-        return
-      i = j
+    elif value == "1": # auto
+        i = 0
+        while True:
+            i = find_token(document.body, '\\begin_inset Formula', i)
+            if i == -1:
+                return
+            j = find_end_of_inset(document.body, i)
+            if j == -1:
+                document.warning("Malformed LyX document: Can't find end of Formula inset at line " + str(i))
+                i += 1
+                continue
+            code = "\n".join(document.body[i:j])
+            for c in undertilde_commands:
+                if code.find("\\%s" % c) != -1:
+                    add_to_preamble(document, ["\\usepackage{undertilde}"])
+                    return
+            i = j
 
 
 def revert_negative_space(document):
-    "Revert InsetSpace negmedspace and negthickspace into its TeX-code counterpart"
+    "Revert InsetSpace negmedspace and negthickspace into their TeX-code counterparts"
     i = 0
     j = 0
     reverted = False
@@ -144,7 +366,7 @@ def revert_negative_space(document):
           if reverted == True:
             i = find_token(document.header, "\\use_amsmath 2", 0)
             if i == -1:
-              add_to_preamble(document, ["\\@ifundefined{negthickspace}{\\usepackage{amsmath}}"])
+              add_to_preamble(document, ["\\@ifundefined{negthickspace}{\\usepackage{amsmath}}{}"])
           return
       if i == -1:
         return
@@ -172,7 +394,7 @@ def revert_math_spaces(document):
         end = find_end_of_inset(document.body, i)
         subst = put_cmd_in_ert(document.body[i][21:])
         document.body[i:end + 1] = subst
-      i = i + 1
+      i += 1
 
 
 def convert_japanese_encodings(document):
@@ -186,7 +408,7 @@ def convert_japanese_encodings(document):
     if i == -1:
         return
     val = get_value(document.header, "\\inputencoding", i)
-    if val in jap_enc_dict.keys():
+    if val in list(jap_enc_dict.keys()):
         document.header[i] = "\\inputencoding %s" % jap_enc_dict[val]
 
 
@@ -201,10 +423,25 @@ def revert_japanese_encodings(document):
     if i == -1:
         return
     val = get_value(document.header, "\\inputencoding", i)
-    if val in jap_enc_dict.keys():
+    if val in list(jap_enc_dict.keys()):
         document.header[i] = "\\inputencoding %s" % jap_enc_dict[val]
 
 
+def convert_justification(document):
+    " Add the \\justification buffer param"
+    i = find_token(document.header, "\\suppress_date" , 0)
+    if i == -1:
+        i = find_token(document.header, "\\paperorientation" , 0)
+    if i == -1:
+        i = find_token(document.header, "\\use_indices" , 0)
+    if i == -1:
+        i = find_token(document.header, "\\use_bibtopic" , 0)
+    if i == -1:
+        document.warning("Malformed LyX document: Missing \\suppress_date.")
+        return
+    document.header.insert(i + 1, "\\justification true")
+
+
 def revert_justification(document):
     " Revert the \\justification buffer param"
     if not del_token(document.header, '\\justification', 0):
@@ -212,16 +449,16 @@ def revert_justification(document):
 
 
 def revert_australian(document):
-    "Set English language variants Australian and Newzealand to English" 
+    "Set English language variants Australian and Newzealand to English"
 
-    if document.language == "australian" or document.language == "newzealand": 
+    if document.language == "australian" or document.language == "newzealand":
         document.language = "english"
-        i = find_token(document.header, "\\language", 0) 
-        if i != -1: 
-            document.header[i] = "\\language english" 
-    j = 0 
-    while True: 
-        j = find_token(document.body, "\\lang australian", j) 
+        i = find_token(document.header, "\\language", 0)
+        if i != -1:
+            document.header[i] = "\\language english"
+    j = 0
+    while True:
+        j = find_token(document.body, "\\lang australian", j)
         if j == -1:
             j = find_token(document.body, "\\lang newzealand", 0)
             if j == -1:
@@ -229,7 +466,7 @@ def revert_australian(document):
             else:
                 document.body[j] = document.body[j].replace("\\lang newzealand", "\\lang english")
         else:
-            document.body[j] = document.body[j].replace("\\lang australian", "\\lang english") 
+            document.body[j] = document.body[j].replace("\\lang australian", "\\lang english")
         j += 1
 
 
@@ -319,8 +556,6 @@ def handle_longtable_captions(document, forward):
                     get_option_value(document.body[begin_row], 'endlastfoot') != 'true'):
                     document.body[begin_row] = set_option_value(document.body[begin_row], 'caption', 'true", endfirsthead="true')
             elif get_option_value(document.body[begin_row], 'caption') == 'true':
-                if get_option_value(document.body[begin_row], 'endfirsthead') == 'true':
-                    document.body[begin_row] = set_option_value(document.body[begin_row], 'endfirsthead', 'false')
                 if get_option_value(document.body[begin_row], 'endhead') == 'true':
                     document.body[begin_row] = set_option_value(document.body[begin_row], 'endhead', 'false')
                 if get_option_value(document.body[begin_row], 'endfoot') == 'true':
@@ -328,7 +563,7 @@ def handle_longtable_captions(document, forward):
                 if get_option_value(document.body[begin_row], 'endlastfoot') == 'true':
                     document.body[begin_row] = set_option_value(document.body[begin_row], 'endlastfoot', 'false')
             begin_row = end_row
-        # since there could be a tabular inside this one, we 
+        # since there could be a tabular inside this one, we
         # cannot jump to end.
         begin_table += 1
 
@@ -355,32 +590,74 @@ def convert_use_packages(document):
 
 def revert_use_packages(document):
     "use_package xxx yyy => use_xxx yyy"
-    packages = ["amsmath", "esint", "mathdots", "mhchem", "undertilde"]
+    packages = ["amsmath", "esint", "mhchem", "mathdots", "undertilde"]
     # the order is arbitrary for the use_package version, and not all packages need to be given.
     # Ensure a complete list and correct order (important for older LyX versions and especially lyx2lyx)
-    j = 0
+    # first loop: find line with first package
+    j = -1
+    for p in packages:
+        regexp = re.compile(r'(\\use_package\s+%s)' % p)
+        i = find_re(document.header, regexp, 0)
+        if i != -1 and (j < 0 or i < j):
+            j = i
+    # second loop: replace or insert packages in front of all existing ones
     for p in packages:
         regexp = re.compile(r'(\\use_package\s+%s)' % p)
-        i = find_re(document.header, regexp, j)
+        i = find_re(document.header, regexp, 0)
         if i != -1:
             value = get_value(document.header, "\\use_package %s" % p, i).split()[1]
             del document.header[i]
-            j = i
-            document.header.insert(j, "\\use_%s %s"  % (p, value))
-        j = j + 1
+            document.header.insert(j, "\\use_%s %s" % (p, value))
+        else:
+            document.header.insert(j, "\\use_%s 1" % p)
+        j += 1
 
 
-def convert_use_package(document, pkg):
-    i = find_token(document.header, "\\use_package", 0)
+def convert_use_package(document, pkg, commands, oldauto):
+    # oldauto defines how the version we are converting from behaves:
+    # if it is true, the old version uses the package automatically.
+    # if it is false, the old version never uses the package.
+    i = find_token(document.header, "\\use_package")
     if i == -1:
         document.warning("Malformed LyX document: Can't find \\use_package.")
         return;
-    j = find_token(document.preamble, "\\usepackage{" + pkg + "}", 0)
-    if j == -1:
-        document.header.insert(i + 1, "\\use_package " + pkg + " 0")
+    packageline = "\\usepackage{%s}" % pkg
+    if (del_complete_lines(document.preamble,
+                           ['% Added by lyx2lyx', packageline]) or
+        del_complete_lines(document.preamble, [packageline])):
+        # package was loaded in the preamble, convert this to header setting
+        document.header.insert(i + 1, "\\use_package " + pkg + " 2") # on
+    # If oldauto is true we have two options:
+    # We can either set the package to auto - this is correct for files in
+    # format 425 to 463, and may create a conflict for older files which use
+    # any command in commands with a different definition.
+    # Or we can look whether any command in commands is used, and set it to
+    # auto if not and to off if yes. This will not create a conflict, but will
+    # create uncompilable documents for files in format 425 to 463, which use
+    # any command in commands.
+    # We choose the first option since its error is less likely.
+    elif oldauto:
+        document.header.insert(i + 1, "\\use_package " + pkg + " 1") # auto
     else:
-        document.header.insert(i + 1, "\\use_package " + pkg + " 2")
-        del document.preamble[j]
+        j = 0
+        while True:
+            j = find_token(document.body, '\\begin_inset Formula', j)
+            if j == -1:
+                break
+            k = find_end_of_inset(document.body, j)
+            if k == -1:
+                document.warning("Malformed LyX document: Can't find end of Formula inset at line " + str(j))
+                j += 1
+                continue
+            code = "\n".join(document.body[j:k])
+            for c in commands:
+                if code.find("\\%s" % c) != -1:
+                    # at least one of the commands was found - need to switch package off
+                    document.header.insert(i + 1, "\\use_package " + pkg + " 0") # off
+                    return
+            j = k
+        # no command was found - set to auto (bug 9069)
+        document.header.insert(i + 1, "\\use_package " + pkg + " 1") # auto
 
 
 def revert_use_package(document, pkg, commands, oldauto):
@@ -414,31 +691,24 @@ def revert_use_package(document, pkg, commands, oldauto):
             i = j
 
 
-def convert_use_mathtools(document):
-    "insert use_package mathtools"
-    convert_use_package(document, "mathtools")
-
-
-def revert_use_mathtools(document):
-    "remove use_package mathtools"
-    commands = ["mathclap", "mathllap", "mathrlap", \
+mathtools_commands = ["mathclap", "mathllap", "mathrlap", \
                 "lgathered", "rgathered", "vcentcolon", "dblcolon", \
                 "coloneqq", "Coloneqq", "coloneq", "Coloneq", "eqqcolon", \
                 "Eqqcolon", "eqcolon", "Eqcolon", "colonapprox", \
                 "Colonapprox", "colonsim", "Colonsim"]
-    revert_use_package(document, "mathtools", commands, False)
+def convert_use_mathtools(document):
+    "insert use_package mathtools"
+    convert_use_package(document, "mathtools", mathtools_commands, False)
 
 
-def convert_use_stmaryrd(document):
-    "insert use_package stmaryrd"
-    convert_use_package(document, "stmaryrd")
+def revert_use_mathtools(document):
+    "remove use_package mathtools"
+    revert_use_package(document, "mathtools", mathtools_commands, False)
 
 
-def revert_use_stmaryrd(document):
-    "remove use_package stmaryrd"
-    # commands provided by stmaryrd.sty but LyX uses other packages:
-    # boxdot lightning, bigtriangledown, bigtriangleup
-    commands = ["shortleftarrow", "shortrightarrow", "shortuparrow", \
+# commands provided by stmaryrd.sty but LyX uses other packages:
+# boxdot lightning, bigtriangledown, bigtriangleup
+stmaryrd_commands = ["shortleftarrow", "shortrightarrow", "shortuparrow", \
                     "shortdownarrow", "Yup", "Ydown", "Yleft", "Yright", \
                     "varcurlyvee", "varcurlywedge", "minuso", "baro", \
                     "sslash", "bbslash", "moo", "varotimes", "varoast", \
@@ -469,19 +739,25 @@ def revert_use_stmaryrd(document):
                     "varcopyright", "longarrownot", "Longarrownot", \
                     "Mapsto", "mapsfrom", "Mapsfrom" "Longmapsto", \
                     "longmapsfrom", "Longmapsfrom"]
-    revert_use_package(document, "stmaryrd", commands, False)
+def convert_use_stmaryrd(document):
+    "insert use_package stmaryrd"
+    convert_use_package(document, "stmaryrd", stmaryrd_commands, False)
 
 
+def revert_use_stmaryrd(document):
+    "remove use_package stmaryrd"
+    revert_use_package(document, "stmaryrd", stmaryrd_commands, False)
 
+
+stackrel_commands = ["stackrel"]
 def convert_use_stackrel(document):
     "insert use_package stackrel"
-    convert_use_package(document, "stackrel")
+    convert_use_package(document, "stackrel", stackrel_commands, False)
 
 
 def revert_use_stackrel(document):
     "remove use_package stackrel"
-    commands = ["stackrel"]
-    revert_use_package(document, "stackrel", commands, False)
+    revert_use_package(document, "stackrel", stackrel_commands, False)
 
 
 def convert_cite_engine_type(document):
@@ -540,65 +816,80 @@ def revert_cite_engine_type_default(document):
     document.header[i] = "\\cite_engine_type " + engine_type
 
 
+cancel_commands = ["cancel", "bcancel", "xcancel", "cancelto"]
 # this is the same, as revert_use_cancel() except for the default
 def revert_cancel(document):
     "add cancel to the preamble if necessary"
-    commands = ["cancelto", "cancel", "bcancel", "xcancel"]
-    revert_use_package(document, "cancel", commands, False)
+    revert_use_package(document, "cancel", cancel_commands, False)
 
 
-def revert_verbatim(document):
-    " Revert verbatim einvironments completely to TeX-code. "
+def revert_verbatim(document, starred = False):
+    " Revert verbatim environments completely to TeX-code. "
     i = 0
     consecutive = False
-    subst_end = ['\end_layout', '', '\\begin_layout Plain Layout',
-    	         '\end_layout', '',
+
+    layout_name = "Verbatim"
+    latex_name  = "verbatim"
+    if starred:
+        layout_name = "Verbatim*"
+        latex_name  = "verbatim*"
+
+    subst_end = ['\\end_layout', '', '\\begin_layout Plain Layout',
+                 '\\end_layout', '',
                  '\\begin_layout Plain Layout', '', '',
                  '\\backslash', '',
-                 'end{verbatim}',
+                 'end{%s}' % (latex_name),
                  '\\end_layout', '', '\\end_inset',
                  '', '', '\\end_layout']
     subst_begin = ['\\begin_layout Standard', '\\noindent',
-                   '\\begin_inset ERT', 'status collapsed', '',
+                   '\\begin_inset ERT', 'status open', '',
                    '\\begin_layout Plain Layout', '', '', '\\backslash',
-                   'begin{verbatim}',
+                   'begin{%s}' % (latex_name),
                    '\\end_layout', '', '\\begin_layout Plain Layout', '']
-    while 1:
-        i = find_token(document.body, "\\begin_layout Verbatim", i)
+
+    while True:
+        i = find_token(document.body, "\\begin_layout %s" % (layout_name), i)
         if i == -1:
             return
         j = find_end_of_layout(document.body, i)
         if j == -1:
-            document.warning("Malformed LyX document: Can't find end of Verbatim layout")
+            document.warning("Malformed LyX document: Can't find end of %s layout" \
+              % (layout_name))
             i += 1
             continue
         # delete all line breaks insets (there are no other insets)
         l = i
-        while 1:
-            n = find_token(document.body, "\\begin_inset Newline newline", l)
+        while True:
+            n = find_token(document.body, "\\begin_inset Newline newline", l, j)
             if n == -1:
-                n = find_token(document.body, "\\begin_inset Newline linebreak", l)
+                n = find_token(document.body, "\\begin_inset Newline linebreak", l, j)
                 if n == -1:
                     break
             m = find_end_of_inset(document.body, n)
             del(document.body[m:m+1])
-            document.body[n:n+1] = ['\end_layout', '', '\\begin_layout Plain Layout']
+            document.body[n:n+1] = ['\\end_layout', '', '\\begin_layout Plain Layout']
             l += 1
-            j += 1
+            # we deleted a line, so the end of the inset moved forward.
+            # FIXME But we also added some lines, didn't we? I think this
+            # should be j += 1.
+            j -= 1
         # consecutive verbatim environments need to be connected
-        k = find_token(document.body, "\\begin_layout Verbatim", j)
+        k = find_token(document.body, "\\begin_layout %s" % (layout_name), j)
         if k == j + 2 and consecutive == False:
             consecutive = True
-            document.body[j:j+1] = ['\end_layout', '', '\\begin_layout Plain Layout']
+            document.body[j:j+1] = ['\\end_layout', '', '\\begin_layout Plain Layout']
             document.body[i:i+1] = subst_begin
             continue
         if k == j + 2 and consecutive == True:
-            document.body[j:j+1] = ['\end_layout', '', '\\begin_layout Plain Layout']
+            document.body[j:j+1] = ['\\end_layout', '', '\\begin_layout Plain Layout']
             del(document.body[i:i+1])
             continue
         if k != j + 2 and consecutive == True:
             document.body[j:j+1] = subst_end
             # the next paragraph must not be indented
+            # FIXME This seems to be causing problems, because of the
+            # hardcoded use of 19. We should figure out exactly where
+            # this needs to go by searching for the right tag.
             document.body[j+19:j+19] = ['\\noindent']
             del(document.body[i:i+1])
             consecutive = False
@@ -606,6 +897,9 @@ def revert_verbatim(document):
         else:
             document.body[j:j+1] = subst_end
             # the next paragraph must not be indented
+            # FIXME This seems to be causing problems, because of the
+            # hardcoded use of 19. We should figure out exactly where
+            # this needs to go by searching for the right tag.
             document.body[j+19:j+19] = ['\\noindent']
             document.body[i:i+1] = subst_begin
 
@@ -613,7 +907,7 @@ def revert_verbatim(document):
 def revert_tipa(document):
     " Revert native TIPA insets to mathed or ERT. "
     i = 0
-    while 1:
+    while True:
         i = find_token(document.body, "\\begin_inset IPA", i)
         if i == -1:
             return
@@ -669,7 +963,7 @@ def revert_cell_rotation(document):
           document.body[i] = rgx.sub('', document.body[i])
         elif value == "90":
           rgx = re.compile(r' rotate="[^"]+?"')
-          document.body[i] = rgx.sub('rotate="true"', document.body[i])
+          document.body[i] = rgx.sub(' rotate="true"', document.body[i])
         else:
           rgx = re.compile(r' rotate="[^"]+?"')
           load_rotating = True
@@ -680,12 +974,12 @@ def revert_cell_rotation(document):
             put_cmd_in_ert("\\end{turn}")
           document.body[i + 4 : i + 4] = \
             put_cmd_in_ert("\\begin{turn}{" + value + "}")
-        
+
       i += 1
-        
+
   finally:
     if load_rotating:
-      add_to_preamble(document, ["\\@ifundefined{turnbox}{\usepackage{rotating}}{}"])
+      add_to_preamble(document, ["\\@ifundefined{turnbox}{\\usepackage{rotating}}{}"])
 
 
 def convert_cell_rotation(document):
@@ -702,7 +996,7 @@ def convert_cell_rotation(document):
         rgx = re.compile(r'rotate="[^"]+?"')
         # convert "true" to "90"
         document.body[i] = rgx.sub('rotate="90"', document.body[i])
-        
+
       i += 1
 
 
@@ -739,12 +1033,12 @@ def revert_table_rotation(document):
             put_cmd_in_ert("\\end{turn}")
           document.body[i - 2 : i - 2] = \
             put_cmd_in_ert("\\begin{turn}{" + value + "}")
-        
+
       i += 1
-        
+
   finally:
     if load_rotating:
-      add_to_preamble(document, ["\\@ifundefined{turnbox}{\usepackage{rotating}}{}"])
+      add_to_preamble(document, ["\\@ifundefined{turnbox}{\\usepackage{rotating}}{}"])
 
 
 def convert_table_rotation(document):
@@ -761,12 +1055,12 @@ def convert_table_rotation(document):
         rgx = re.compile(r'rotate="[^"]+?"')
         # convert "true" to "90"
         document.body[i] = rgx.sub('rotate="90"', document.body[i])
-        
+
       i += 1
 
 
 def convert_listoflistings(document):
-    'Convert ERT \lstlistoflistings to TOC lstlistoflistings inset'
+    r'Convert ERT \lstlistoflistings to TOC lstlistoflistings inset'
     # We can support roundtrip because the command is so simple
     i = 0
     while True:
@@ -802,7 +1096,7 @@ def revert_listoflistings(document):
             subst = put_cmd_in_ert("\\lstlistoflistings{}")
             document.body[i:j+1] = subst
             add_to_preamble(document, ["\\usepackage{listings}"])
-        i = i + 1
+        i += 1
 
 
 def convert_use_amssymb(document):
@@ -846,78 +1140,69 @@ def revert_use_amssymb(document):
 
 def convert_use_cancel(document):
     "insert use_package cancel"
-    convert_use_package(document, "cancel")
+    convert_use_package(document, "cancel", cancel_commands, True)
 
 
 def revert_use_cancel(document):
     "remove use_package cancel"
-    commands = ["cancel", "bcancel", "xcancel", "cancelto"]
-    revert_use_package(document, "cancel", commands, True)
+    revert_use_package(document, "cancel", cancel_commands, True)
 
 
 def revert_ancientgreek(document):
-    "Set the document language for ancientgreek to greek" 
+    "Set the document language for ancientgreek to greek"
 
-    if document.language == "ancientgreek": 
+    if document.language == "ancientgreek":
         document.language = "greek"
-        i = find_token(document.header, "\\language", 0) 
-        if i != -1: 
-            document.header[i] = "\\language greek" 
-    j = 0 
-    while True: 
-        j = find_token(document.body, "\\lang ancientgreek", j) 
+        i = find_token(document.header, "\\language", 0)
+        if i != -1:
+            document.header[i] = "\\language greek"
+    j = 0
+    while True:
+        j = find_token(document.body, "\\lang ancientgreek", j)
         if j == -1:
             return
         else:
-            document.body[j] = document.body[j].replace("\\lang ancientgreek", "\\lang greek") 
+            document.body[j] = document.body[j].replace("\\lang ancientgreek", "\\lang greek")
         j += 1
 
 
 def revert_languages(document):
-    "Set the document language for new supported languages to English" 
-
-    languages = [
-                 "coptic", "divehi", "hindi", "kurmanji", "lao", "marathi", "occitan", "sanskrit",
-                 "syriac", "tamil", "telugu", "urdu"
-                ]
-    for n in range(len(languages)):
-        if document.language == languages[n]:
-            document.language = "english"
-            i = find_token(document.header, "\\language", 0) 
-            if i != -1: 
-                document.header[i] = "\\language english" 
-        j = 0
-        while j < len(document.body): 
-            j = find_token(document.body, "\\lang " + languages[n], j)
-            if j != -1:
-                document.body[j] = document.body[j].replace("\\lang " + languages[n], "\\lang english")
-                j += 1
-            else:
-                j = len(document.body)
+    "Set the document language for new supported languages to English"
+
+    # polyglossia-only
+    polyglossia_languages = ["coptic", "divehi", "hindi", "lao", "marathi",
+                             "occitan", "sanskrit", "syriac", "tamil",
+                             "telugu", "urdu"]
+    # babel-only
+    babel_languages = ["kurmanji"]
+    for lang in polyglossia_languages:
+        revert_language(document, lang, "", lang)
+    for lang in babel_languages:
+        revert_language(document, lang, lang, "")
 
 
 def convert_armenian(document):
-    "Use polyglossia and thus non-TeX fonts for Armenian" 
+    "Use polyglossia and thus non-TeX fonts for Armenian"
 
-    if document.language == "armenian": 
-        i = find_token(document.header, "\\use_non_tex_fonts", 0) 
-        if i != -1: 
-            document.header[i] = "\\use_non_tex_fonts true" 
+    if document.language == "armenian":
+        i = find_token(document.header, "\\use_non_tex_fonts", 0)
+        if i != -1:
+            document.header[i] = "\\use_non_tex_fonts true"
 
 
 def revert_armenian(document):
-    "Use ArmTeX and thus TeX fonts for Armenian" 
+    "Use ArmTeX and thus TeX fonts for Armenian"
 
-    if document.language == "armenian": 
-        i = find_token(document.header, "\\use_non_tex_fonts", 0) 
-        if i != -1: 
-            document.header[i] = "\\use_non_tex_fonts false" 
+    if document.language == "armenian":
+        i = find_token(document.header, "\\use_non_tex_fonts", 0)
+        if i != -1:
+            document.header[i] = "\\use_non_tex_fonts false"
 
 
 def revert_libertine(document):
-    " Revert native libertine font definition to LaTeX " 
+    " Revert native libertine font definition to LaTeX "
 
-    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: 
+    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
         i = find_token(document.header, "\\font_roman libertine", 0)
         if i != -1:
             osf = False
@@ -936,9 +1221,9 @@ def revert_libertine(document):
 
 
 def revert_txtt(document):
-    " Revert native txtt font definition to LaTeX " 
+    " Revert native txtt font definition to LaTeX "
 
-    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: 
+    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
         i = find_token(document.header, "\\font_typewriter txtt", 0)
         if i != -1:
             preamble = "\\renewcommand{\\ttdefault}{txtt}"
@@ -947,9 +1232,9 @@ def revert_txtt(document):
 
 
 def revert_mathdesign(document):
-    " Revert native mathdesign font definition to LaTeX " 
+    " Revert native mathdesign font definition to LaTeX "
 
-    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: 
+    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
         mathdesign_dict = {
         "mdbch":  "charter",
         "mdput":  "utopia",
@@ -959,7 +1244,7 @@ def revert_mathdesign(document):
         if i == -1:
             return
         val = get_value(document.header, "\\font_roman", i)
-        if val in mathdesign_dict.keys():
+        if val in list(mathdesign_dict.keys()):
             preamble = "\\usepackage[%s" % mathdesign_dict[val]
             expert = False
             j = find_token(document.header, "\\font_osf true", 0)
@@ -978,9 +1263,9 @@ def revert_mathdesign(document):
 
 
 def revert_texgyre(document):
-    " Revert native TeXGyre font definition to LaTeX " 
+    " Revert native TeXGyre font definition to LaTeX "
 
-    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: 
+    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
         texgyre_fonts = ["tgadventor", "tgbonum", "tgchorus", "tgcursor", \
                          "tgheros", "tgpagella", "tgschola", "tgtermes"]
         i = find_token(document.header, "\\font_roman", 0)
@@ -1037,7 +1322,7 @@ def revert_ipadeco(document):
           i = end
           continue
       substi = ["\\begin_inset ERT", "status collapsed", "",
-                "\\begin_layout Plain Layout", "", "", "\\backslash", 
+                "\\begin_layout Plain Layout", "", "", "\\backslash",
                 decotype + "{", "\\end_layout", "", "\\end_inset"]
       substj = ["\\size default", "", "\\begin_inset ERT", "status collapsed", "",
                 "\\begin_layout Plain Layout", "", "}", "\\end_layout", "", "\\end_inset"]
@@ -1071,15 +1356,15 @@ def revert_ipachar(document):
             document.body[i: i+1] = subst
             i = i + len(subst)
         else:
-            i = i + 1
+            i += 1
     if found:
         add_to_preamble(document, "\\usepackage{tone}")
 
 
 def revert_minionpro(document):
-    " Revert native MinionPro font definition to LaTeX " 
+    " Revert native MinionPro font definition to LaTeX "
 
-    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: 
+    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
         i = find_token(document.header, "\\font_roman minionpro", 0)
         if i != -1:
             osf = False
@@ -1097,12 +1382,12 @@ def revert_minionpro(document):
 
 
 def revert_mathfonts(document):
-    " Revert native math font definitions to LaTeX " 
+    " Revert native math font definitions to LaTeX "
 
     i = find_token(document.header, "\\font_math", 0)
     if i == -1:
        return
-    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: 
+    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
         val = get_value(document.header, "\\font_math", i)
         if val == "eulervm":
             add_to_preamble(document, "\\usepackage{eulervm}")
@@ -1123,7 +1408,7 @@ def revert_mathfonts(document):
                 k = find_token(document.header, "\\font_osf true", 0)
                 if k != -1:
                     rm += "-osf"
-                if rm in mathfont_dict.keys():
+                if rm in list(mathfont_dict.keys()):
                     add_to_preamble(document, mathfont_dict[rm])
                     document.header[j] = "\\font_roman default"
                     if k != -1:
@@ -1132,9 +1417,9 @@ def revert_mathfonts(document):
 
 
 def revert_mdnomath(document):
-    " Revert mathdesign and fourier without math " 
+    " Revert mathdesign and fourier without math "
 
-    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: 
+    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
         mathdesign_dict = {
         "md-charter": "mdbch",
         "md-utopia": "mdput",
@@ -1144,7 +1429,7 @@ def revert_mdnomath(document):
         if i == -1:
             return
         val = get_value(document.header, "\\font_roman", i)
-        if val in mathdesign_dict.keys():
+        if val in list(mathdesign_dict.keys()):
             j = find_token(document.header, "\\font_math", 0)
             if j == -1:
                 document.header[i] = "\\font_roman %s" % mathdesign_dict[val]
@@ -1156,10 +1441,14 @@ def revert_mdnomath(document):
                 document.header[i] = "\\font_roman %s" % mathdesign_dict[val]
 
 
+def convert_mathfonts(document):
+    document.header.insert(-1, "\\font_math auto")
+
+
 def convert_mdnomath(document):
-    " Change mathdesign font name " 
+    " Change mathdesign font name "
 
-    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: 
+    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
         mathdesign_dict = {
         "mdbch":  "md-charter",
         "mdput":  "md-utopia",
@@ -1169,32 +1458,32 @@ def convert_mdnomath(document):
         if i == -1:
             return
         val = get_value(document.header, "\\font_roman", i)
-        if val in mathdesign_dict.keys():
+        if val in list(mathdesign_dict.keys()):
              document.header[i] = "\\font_roman %s" % mathdesign_dict[val]
 
 
 def revert_newtxmath(document):
-    " Revert native newtxmath definitions to LaTeX " 
+    " Revert native newtxmath definitions to LaTeX "
 
     i = find_token(document.header, "\\font_math", 0)
     if i == -1:
        return
-    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: 
+    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
         val = get_value(document.header, "\\font_math", i)
         mathfont_dict = {
         "libertine-ntxm":  "\\usepackage[libertine]{newtxmath}",
         "minion-ntxm":  "\\usepackage[minion]{newtxmath}",
         "newtxmath":  "\\usepackage{newtxmath}",
         }
-        if val in mathfont_dict.keys():
+        if val in list(mathfont_dict.keys()):
             add_to_preamble(document, mathfont_dict[val])
             document.header[i] = "\\font_math auto"
 
 
 def revert_biolinum(document):
-    " Revert native biolinum font definition to LaTeX " 
+    " Revert native biolinum font definition to LaTeX "
 
-    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: 
+    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
         i = find_token(document.header, "\\font_sans biolinum", 0)
         if i != -1:
             osf = False
@@ -1249,19 +1538,20 @@ def convert_latexargs(document):
                     "svglobal3", "svglobal", "svjog", "svmono", "svmult", "svprobth", "tarticle",
                     "tbook", "treport", "tufte-book", "tufte-handout"]
     # A list of "safe" modules, same as above
-    safe_modules = ["biblatex", "beameraddons", "beamersession", "braille", "customHeadersFooters",
-                    "endnotes", "enumitem", "eqs-within-sections", "figs-within-sections", "fix-cm",
-                    "fixltx2e", "foottoend", "hanging", "jscharstyles", "knitr", "lilypond",
+    safe_modules = ["biblatex", "beameraddons", "beamer-resenumerate", "beamersession", "braille",
+                    "customHeadersFooters", "endnotes", "enumitem", "eqs-within-sections", "figs-within-sections",
+                    "fix-cm", "fixltx2e", "foottoend", "hanging", "jscharstyles", "knitr", "lilypond",
                     "linguistics", "linguisticx", "logicalmkup", "minimalistic", "nomindex", "noweb",
                     "pdfcomment", "sweave", "tabs-within-sections", "theorems-ams-bytype",
                     "theorems-ams-extended-bytype", "theorems-ams-extended", "theorems-ams", "theorems-bytype",
                     "theorems-chap-bytype", "theorems-chap", "theorems-named", "theorems-sec-bytype",
                     "theorems-sec", "theorems-starred", "theorems-std", "todonotes"]
     # Modules we need to take care of
-    caveat_modules = ["initials"]
+    caveat_modules = ["initials"] # TODO: , "graphicboxes", "bicaption"]
     # information about the relevant styles in caveat_modules (number of opt and req args)
     # use this if we get more caveat_modules. For now, use hard coding (see below).
     # initials = [{'Layout' : 'Initial', 'opt' : 1, 'req' : 1}]
+    # graphicboxes = { ... }
 
     # Is this a known safe layout?
     safe_layout = document.textclass in safe_layouts
@@ -1295,14 +1585,14 @@ def convert_latexargs(document):
             # InsetArgument itself will do the real work
             # (see InsetArgument::updateBuffer())
             document.body[i] = "\\begin_inset Argument 999"
-            i = i + 1
+            i += 1
             continue
-        
+
         # Find containing paragraph layout
         parent = get_containing_layout(document.body, i)
         if parent == False:
             document.warning("Malformed LyX document: Can't find parent paragraph layout")
-            i = i + 1
+            i += 1
             continue
         parbeg = parent[1]
         parend = parent[2]
@@ -1332,7 +1622,7 @@ def convert_latexargs(document):
                     if argnr > allowed_opts and argnr < first_req:
                         argnr = first_req
                 document.body[p] = "\\begin_inset Argument %d" % argnr
-        i = i + 1
+        i = parend + 1
 
 
 def revert_latexargs(document):
@@ -1349,22 +1639,28 @@ def revert_latexargs(document):
         m = rx.match(document.body[i])
         if not m:
             # No ID: inset already reverted
-            i = i + 1
+            i += 1
             continue
         # Find containing paragraph layout
         parent = get_containing_layout(document.body, i)
         if parent == False:
             document.warning("Malformed LyX document: Can't find parent paragraph layout")
-            i = i + 1
+            i += 1
             continue
         parbeg = parent[1]
         parend = parent[2]
-        realparbeg = parent[3]
-        # Collect all arguments in this paragraph 
+        # Do not set realparbeg to parent[3], since this does not work if we
+        # have another inset (e.g. label or index) before the first argument
+        # inset (this is the case in the user guide of LyX 2.0.8)
+        realparbeg = -1
+        # Collect all arguments in this paragraph
         realparend = parend
         for p in range(parbeg, parend):
             m = rx.match(document.body[p])
             if m:
+                if realparbeg < 0:
+                    # This is the first argument inset
+                    realparbeg = p
                 val = int(m.group(1))
                 j = find_end_of_inset(document.body, p)
                 # Revert to old syntax
@@ -1380,8 +1676,11 @@ def revert_latexargs(document):
                 del document.body[p : j + 1]
             if p >= realparend:
                 break
+        if realparbeg < 0:
+            # No argument inset found
+            realparbeg = parent[3]
         # Now sort the arg insets
-        subst = [""]
+        subst = []
         for f in sorted(args):
             subst += args[f]
             del args[f]
@@ -1391,206 +1690,50 @@ def revert_latexargs(document):
         i = realparbeg + 1 + len(subst)
 
 
-def revert_Argument_to_TeX_brace(document, line, endline, n, nmax, environment, opt):
+def revert_IEEEtran(document):
     '''
-    Reverts an InsetArgument to TeX-code
-    usage:
-    revert_Argument_to_TeX_brace(document, LineOfBegin, LineOfEnd, StartArgument, EndArgument, isEnvironment, isOpt)
-    LineOfBegin is the line  of the \begin_layout or \begin_inset statement
-    LineOfEnd is the line  of the \end_layout or \end_inset statement, if "0" is given, the end of the file is used instead
-    StartArgument is the number of the first argument that needs to be converted
-    EndArgument is the number of the last argument that needs to be converted or the last defined one
-    isEnvironment must be true, if the layout is for a LaTeX environment
-    isOpt must be true, if the argument is an optional one
+    Reverts InsetArgument of
+    Page headings
+    Biography
+    Biography without photo
+    to TeX-code
     '''
-    lineArg = 0
-    wasOpt = False
-    while lineArg != -1 and n < nmax + 1:
-      lineArg = find_token(document.body, "\\begin_inset Argument " + str(n), line)
-      if lineArg > endline and endline != 0:
-        return wasOpt
-      if lineArg != -1:
-        beginPlain = find_token(document.body, "\\begin_layout Plain Layout", lineArg)
-        # we have to assure that no other inset is in the Argument
-        beginInset = find_token(document.body, "\\begin_inset", beginPlain)
-        endInset = find_token(document.body, "\\end_inset", beginPlain)
-        k = beginPlain + 1
-        l = k
-        while beginInset < endInset and beginInset != -1:
-          beginInset = find_token(document.body, "\\begin_inset", k)
-          endInset = find_token(document.body, "\\end_inset", l)
-          k = beginInset + 1
-          l = endInset + 1
-        if environment == False:
-          if opt == False:
-            document.body[endInset - 2 : endInset + 1] = put_cmd_in_ert("}{")
-            del(document.body[lineArg : beginPlain + 1])
-            wasOpt = False
-          else:
-            document.body[endInset - 2 : endInset + 1] = put_cmd_in_ert("]")
-            document.body[lineArg : beginPlain + 1] = put_cmd_in_ert("[")
-            wasOpt = True
-        else:
-          document.body[endInset - 2 : endInset + 1] = put_cmd_in_ert("}")
-          document.body[lineArg : beginPlain + 1] = put_cmd_in_ert("{")
-          wasOpt = False
-        n = n + 1
-    return wasOpt
-
+    if document.textclass != "IEEEtran":
+        return
 
-def convert_TeX_brace_to_Argument(document, line, n, nmax, inset, environment):
-    '''
-    Converts TeX code for mandatory arguments to an InsetArgument
-    The conversion of TeX code for optional arguments must be done with another routine
-    !!! Be careful if the braces are different in your case as expected here:
-    - "}{" separates mandatory arguments of commands
-    - "}" + "{" separates mandatory arguments of commands
-    - "}" + " " + "{" separates mandatory arguments of commands
-    - { and } surround a mandatory argument of an environment
-    usage:
-    convert_TeX_brace_to_Argument(document, LineOfBeginLayout/Inset, StartArgument, EndArgument, isInset, isEnvironment)
-    LineOfBeginLayout/Inset is the line  of the \begin_layout or \begin_inset statement
-    StartArgument is the number of the first ERT that needs to be converted
-    EndArgument is the number of the last ERT that needs to be converted
-    isInset must be true, if braces inside an InsetLayout needs to be converted
-    isEnvironment must be true, if the layout is for a LaTeX environment
-    
-    Todo: this routine can currently handle only one mandatory argument of environments
-    '''
-    lineERT = line
-    endn = line
-    loop = 1
-    while lineERT != -1 and n < nmax + 1:
-      lineERT = find_token(document.body, "\\begin_inset ERT", lineERT)
-      if environment == False and lineERT != -1:
-        bracePair = find_token(document.body, "}{", lineERT)
-        # assure that the "}{" is in this ERT
-        if bracePair == lineERT + 5:
-          end = find_token(document.body, "\\end_inset", bracePair)
-          document.body[lineERT : end + 1] = ["\\end_layout", "", "\\end_inset"]
-          if loop == 1:
-            # in the case that n > 1 we have optional arguments before
-            # therefore detect them if any
-            if n > 1:
-              # first check if there is an argument
-              lineArg = find_token(document.body, "\\begin_inset Argument", line)
-              if lineArg < lineERT and lineArg != -1:
-                # we have an argument, so now search backwards for its end
-                # we must now assure that we don't find other insets like e.g. a newline
-                endInsetArg = lineERT
-                endLayoutArg = endInsetArg
-                while endInsetArg != endLayoutArg + 2 and endInsetArg != -1:
-                  endInsetArg = endInsetArg - 1
-                  endLayoutArg = endInsetArg
-                  endInsetArg = find_token_backwards(document.body, "\\end_inset", endInsetArg)
-                  endLayoutArg = find_token_backwards(document.body, "\\end_layout", endLayoutArg)
-                line = endInsetArg + 1
-            if inset == False:
-              document.body[line + 1 : line + 1] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
-            else:
-              document.body[line + 4 : line + 4] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
-          else:
-            document.body[endn : endn] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
-          n = n + 1
-          endn = end
-          loop = loop + 1
-        # now check the case that we have "}" + "{" in two ERTs
-        else:
-          endBrace = find_token(document.body, "}", lineERT)
-          if endBrace == lineERT + 5:
-            beginBrace = find_token(document.body, "{", endBrace)
-            # assure that the ERTs are consecutive (11 or 12 depending if there is a space between the ERTs or not)
-            if beginBrace == endBrace + 11 or beginBrace == endBrace + 12:
-              end = find_token(document.body, "\\end_inset", beginBrace)
-              document.body[lineERT : end + 1] = ["\\end_layout", "", "\\end_inset"]
-              if loop == 1:
-                # in the case that n > 1 we have optional arguments before
-                # therefore detect them if any
-                if n > 1:
-                  # first check if there is an argument
-                  lineArg = find_token(document.body, "\\begin_inset Argument", line)
-                  if lineArg < lineERT and lineArg != -1:
-                    # we have an argument, so now search backwards for its end
-                    # we must now assure that we don't find other insets like e.g. a newline
-                    endInsetArg = lineERT
-                    endLayoutArg = endInsetArg
-                    while endInsetArg != endLayoutArg + 2 and endInsetArg != -1:
-                      endInsetArg = endInsetArg - 1
-                      endLayoutArg = endInsetArg
-                      endInsetArg = find_token_backwards(document.body, "\\end_inset", endInsetArg)
-                      endLayoutArg = find_token_backwards(document.body, "\\end_layout", endLayoutArg)
-                    line = endInsetArg + 1
-                if inset == False:
-                  document.body[line + 1 : line + 1] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
-                else:
-                  document.body[line + 4 : line + 4] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
-              else:
-                document.body[endn : endn] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
-              n = n + 1
-              loop = loop + 1
-              # set the line where the next argument will be inserted
-              if beginBrace == endBrace + 11:
-                endn = end - 11
-              else:
-                endn = end - 12
-          else:
-            lineERT = lineERT + 1
-      if environment == True and lineERT != -1:
-        opening = find_token(document.body, "{", lineERT)
-        if opening == lineERT + 5: # assure that the "{" is in this ERT
-          end = find_token(document.body, "\\end_inset", opening)
-          document.body[lineERT : end + 1] = ["\\begin_inset Argument " + str(n), "status open", "", "\\begin_layout Plain Layout"]
-          n = n + 1
-          lineERT2 = find_token(document.body, "\\begin_inset ERT", lineERT)
-          closing = find_token(document.body, "}", lineERT2)
-          if closing == lineERT2 + 5: # assure that the "}" is in this ERT
-            end2 = find_token(document.body, "\\end_inset", closing)
-            document.body[lineERT2 : end2 + 1] = ["\\end_layout", "", "\\end_inset"]
-        else:
-          lineERT = lineERT + 1
+    layouts = {"Page headings": False,
+               "Biography without photo": True}
 
+    for layout in list(layouts.keys()):
+        i = 0
+        while True:
+            i = find_token(document.body, '\\begin_layout ' + layout, i)
+            if i == -1:
+                break
+            revert_Argument_to_TeX_brace(document, i, 0, 1, 1, layouts[layout], False)
+            i += 1
 
-def revert_IEEEtran(document):
-  '''
-  Reverts InsetArgument of
-  Page headings
-  Biography
-  Biography without photo
-  to TeX-code
-  '''
-  if document.textclass == "IEEEtran":
     i = 0
-    i2 = 0
-    j = 0
-    k = 0
     while True:
-      if i != -1:
-        i = find_token(document.body, "\\begin_layout Page headings", i)
-      if i != -1:
+        i = find_token(document.body, '\\begin_inset Flex Paragraph Start', i)
+        if i == -1:
+            break
         revert_Argument_to_TeX_brace(document, i, 0, 1, 1, False, False)
-        i = i + 1
-      if i2 != -1:
-        i2 = find_token(document.body, "\\begin_inset Flex Paragraph Start", i2)
-      if i2 != -1:
-        revert_Argument_to_TeX_brace(document, i2, 0, 1, 1, False, False)
-        i2 = i2 + 1
-      if j != -1:
-        j = find_token(document.body, "\\begin_layout Biography without photo", j)
-      if j != -1:
-        revert_Argument_to_TeX_brace(document, j, 0, 1, 1, True, False)
-        j = j + 1
-      if k != -1:
-        k = find_token(document.body, "\\begin_layout Biography", k)
-        kA = find_token(document.body, "\\begin_layout Biography without photo", k)
-        if k == kA and k != -1:
-          k = k + 1
-          continue
-      if k != -1:
+        i += 1
+
+    i = 0
+    while True:
+        i = find_token_exact(document.body, "\\begin_layout Biography", i)
+        if i == -1:
+                break
+
+        if document.body[i] == "\\begin_layout Biography without photo":
+            i += 1
+            continue
+
         # start with the second argument, therefore 2
-        revert_Argument_to_TeX_brace(document, k, 0, 2, 2, True, False)
-        k = k + 1
-      if i == -1 and i2 == -1 and j == -1 and k == -1:
-        return
+        revert_Argument_to_TeX_brace(document, i, 0, 2, 2, True, False)
+        i += 1
 
 
 def revert_IEEEtran_2(document):
@@ -1600,53 +1743,51 @@ def revert_IEEEtran_2(document):
   if document.textclass == "IEEEtran":
     begin = 0
     while True:
-      if begin != -1:
-        begin = find_token(document.body, "\\begin_inset Flex Paragraph Start", begin)
-      if begin != -1:
-        end1 = find_end_of_inset(document.body, begin)
-        document.body[end1 - 2 : end1 + 1] = put_cmd_in_ert("}")
-        document.body[begin : begin + 4] = put_cmd_in_ert("\\IEEEPARstart{")
-        begin = begin + 5
+      begin = find_token(document.body, "\\begin_inset Flex Paragraph Start", begin)
       if begin == -1:
         return
+      end1 = find_end_of_inset(document.body, begin)
+      document.body[end1 - 2 : end1 + 1] = put_cmd_in_ert("}")
+      document.body[begin : begin + 4] = put_cmd_in_ert("\\IEEEPARstart{")
+      begin = begin + 5
 
 
 def convert_IEEEtran(document):
-  '''
-  Converts ERT of
-  Page headings
-  Biography
-  Biography without photo
-  to InsetArgument
-  '''
-  if document.textclass == "IEEEtran":
+    '''
+    Converts ERT of
+    Page headings
+    Biography
+    Biography without photo
+    to InsetArgument
+    '''
+    if document.textclass != "IEEEtran":
+        return
+
+    layouts = {"Page headings": False,
+               "Biography without photo": True}
+
+    for layout in list(layouts.keys()):
+        i = 0
+        while True:
+            i = find_token(document.body, '\\begin_layout ' + layout, i)
+            if i == -1:
+                break
+            convert_TeX_brace_to_Argument(document, i, 1, 1, False, layouts[layout], False)
+            i += 1
+
     i = 0
-    j = 0
-    k = 0
     while True:
-      if i != -1:
-        i = find_token(document.body, "\\begin_layout Page headings", i)
-      if i != -1:
-        convert_TeX_brace_to_Argument(document, i, 1, 1, False, False)
-        i = i + 1
-      if j != -1:
-        j = find_token(document.body, "\\begin_layout Biography without photo", j)
-      if j != -1:
-        convert_TeX_brace_to_Argument(document, j, 1, 1, False, True)
-        j = j + 1
-      if k != -1:
-        # assure that we don't handle Biography Biography without photo
-        k = find_token(document.body, "\\begin_layout Biography", k)
-        kA = find_token(document.body, "\\begin_layout Biography without photo", k - 1)
-      if k == kA and k != -1:
-        k = k + 1
-        continue
-      if k != -1:
+        i = find_token_exact(document.body, "\\begin_layout Biography", i)
+        if i == -1:
+                break
+
+        if document.body[i] == "\\begin_layout Biography without photo":
+            i += 1
+            continue
+
         # the argument we want to convert is the second one
-        convert_TeX_brace_to_Argument(document, k, 2, 2, False, True)
-        k = k + 1
-      if i == -1 and j == -1 and k == -1:
-        return
+        convert_TeX_brace_to_Argument(document, i, 2, 2, False, True, False)
+        i += 1
 
 
 def revert_AASTeX(document):
@@ -1654,13 +1795,11 @@ def revert_AASTeX(document):
   if document.textclass == "aastex":
     i = 0
     while True:
-      if i != -1:
-        i = find_token(document.body, "\\begin_layout Altaffilation", i)
-      if i != -1:
-        revert_Argument_to_TeX_brace(document, i, 0, 1, 1, False, False)
-        i = i + 1
+      i = find_token(document.body, "\\begin_layout Altaffilation", i)
       if i == -1:
         return
+      revert_Argument_to_TeX_brace(document, i, 0, 1, 1, False, False)
+      i += 1
 
 
 def convert_AASTeX(document):
@@ -1668,13 +1807,11 @@ def convert_AASTeX(document):
   if document.textclass == "aastex":
     i = 0
     while True:
-      if i != -1:
-        i = find_token(document.body, "\\begin_layout Altaffilation", i)
-      if i != -1:
-        convert_TeX_brace_to_Argument(document, i, 1, 1, False, False)
-        i = i + 1
+      i = find_token(document.body, "\\begin_layout Altaffilation", i)
       if i == -1:
         return
+      convert_TeX_brace_to_Argument(document, i, 1, 1, False, False, False)
+      i += 1
 
 
 def revert_AGUTeX(document):
@@ -1682,13 +1819,11 @@ def revert_AGUTeX(document):
   if document.textclass == "agutex":
     i = 0
     while True:
-      if i != -1:
-        i = find_token(document.body, "\\begin_layout Author affiliation", i)
-      if i != -1:
-        revert_Argument_to_TeX_brace(document, i, 0, 1, 1, False, False)
-        i = i + 1
+      i = find_token(document.body, "\\begin_layout Author affiliation", i)
       if i == -1:
         return
+      revert_Argument_to_TeX_brace(document, i, 0, 1, 1, False, False)
+      i += 1
 
 
 def convert_AGUTeX(document):
@@ -1696,13 +1831,11 @@ def convert_AGUTeX(document):
   if document.textclass == "agutex":
     i = 0
     while True:
-      if i != -1:
-        i = find_token(document.body, "\\begin_layout Author affiliation", i)
-      if i != -1:
-        convert_TeX_brace_to_Argument(document, i, 1, 1, False, False)
-        i = i + 1
+      i = find_token(document.body, "\\begin_layout Author affiliation", i)
       if i == -1:
         return
+      convert_TeX_brace_to_Argument(document, i, 1, 1, False, False, False)
+      i += 1
 
 
 def revert_IJMP(document):
@@ -1710,13 +1843,11 @@ def revert_IJMP(document):
   if document.textclass == "ijmpc" or document.textclass == "ijmpd":
     i = 0
     while True:
-      if i != -1:
-        i = find_token(document.body, "\\begin_layout MarkBoth", i)
-      if i != -1:
-        revert_Argument_to_TeX_brace(document, i, 0, 1, 1, False, False)
-        i = i + 1
+      i = find_token(document.body, "\\begin_layout MarkBoth", i)
       if i == -1:
         return
+      revert_Argument_to_TeX_brace(document, i, 0, 1, 1, False, False)
+      i += 1
 
 
 def convert_IJMP(document):
@@ -1724,13 +1855,11 @@ def convert_IJMP(document):
   if document.textclass == "ijmpc" or document.textclass == "ijmpd":
     i = 0
     while True:
-      if i != -1:
-        i = find_token(document.body, "\\begin_layout MarkBoth", i)
-      if i != -1:
-        convert_TeX_brace_to_Argument(document, i, 1, 1, False, False)
-        i = i + 1
+      i = find_token(document.body, "\\begin_layout MarkBoth", i)
       if i == -1:
         return
+      convert_TeX_brace_to_Argument(document, i, 1, 1, False, False, False)
+      i += 1
 
 
 def revert_SIGPLAN(document):
@@ -1743,12 +1872,12 @@ def revert_SIGPLAN(document):
         i = find_token(document.body, "\\begin_layout Conference", i)
       if i != -1:
         revert_Argument_to_TeX_brace(document, i, 0, 1, 1, False, False)
-        i = i + 1
+        i += 1
       if j != -1:
         j = find_token(document.body, "\\begin_layout Author", j)
       if j != -1:
         revert_Argument_to_TeX_brace(document, j, 0, 1, 2, False, False)
-        j = j + 1
+        j += 1
       if i == -1 and j == -1:
         return
 
@@ -1762,13 +1891,13 @@ def convert_SIGPLAN(document):
       if i != -1:
         i = find_token(document.body, "\\begin_layout Conference", i)
       if i != -1:
-        convert_TeX_brace_to_Argument(document, i, 1, 1, False, False)
-        i = i + 1
+        convert_TeX_brace_to_Argument(document, i, 1, 1, False, False, False)
+        i += 1
       if j != -1:
         j = find_token(document.body, "\\begin_layout Author", j)
       if j != -1:
-        convert_TeX_brace_to_Argument(document, j, 1, 2, False, False)
-        j = j + 1
+        convert_TeX_brace_to_Argument(document, j, 1, 2, False, False, False)
+        j += 1
       if i == -1 and j == -1:
         return
 
@@ -1778,13 +1907,11 @@ def revert_SIGGRAPH(document):
   if document.textclass == "acmsiggraph":
     i = 0
     while True:
-      if i != -1:
-        i = find_token(document.body, "\\begin_inset Flex CRcat", i)
-      if i != -1:
-        revert_Argument_to_TeX_brace(document, i, 0, 1, 3, False, False)
-        i = i + 1
+      i = find_token(document.body, "\\begin_inset Flex CRcat", i)
       if i == -1:
         return
+      revert_Argument_to_TeX_brace(document, i, 0, 1, 3, False, False)
+      i += 1
 
 
 def convert_SIGGRAPH(document):
@@ -1792,13 +1919,11 @@ def convert_SIGGRAPH(document):
   if document.textclass == "acmsiggraph":
     i = 0
     while True:
-      if i != -1:
-        i = find_token(document.body, "\\begin_inset Flex CRcat", i)
-      if i != -1:
-        convert_TeX_brace_to_Argument(document, i, 1, 3, True, False)
-        i = i + 1
+      i = find_token(document.body, "\\begin_inset Flex CRcat", i)
       if i == -1:
         return
+      convert_TeX_brace_to_Argument(document, i, 1, 3, True, False, False)
+      i += 1
 
 
 def revert_EuropeCV(document):
@@ -1813,22 +1938,22 @@ def revert_EuropeCV(document):
         i = find_token(document.body, "\\begin_layout Item", i)
       if i != -1:
         revert_Argument_to_TeX_brace(document, i, 0, 2, 2, False, False)
-        i = i + 1
+        i += 1
       if j != -1:
         j = find_token(document.body, "\\begin_layout BulletedItem", j)
       if j != -1:
         revert_Argument_to_TeX_brace(document, j, 0, 2, 2, False, False)
-        j = j + 1
+        j += 1
       if k != -1:
         k = find_token(document.body, "\\begin_layout Language", k)
       if k != -1:
         revert_Argument_to_TeX_brace(document, k, 0, 2, 6, False, False)
-        k = k + 1
+        k += 1
       if m != -1:
         m = find_token(document.body, "\\begin_layout LastLanguage", m)
       if m != -1:
         revert_Argument_to_TeX_brace(document, m, 0, 2, 6, False, False)
-        m = m + 1
+        m += 1
       if i == -1 and j == -1 and k == -1 and m == -1:
         return
 
@@ -1844,23 +1969,23 @@ def convert_EuropeCV(document):
       if i != -1:
         i = find_token(document.body, "\\begin_layout Item", i)
       if i != -1:
-        convert_TeX_brace_to_Argument(document, i, 2, 2, False, False)
-        i = i + 1
+        convert_TeX_brace_to_Argument(document, i, 2, 2, False, False, False)
+        i += 1
       if j != -1:
         j = find_token(document.body, "\\begin_layout BulletedItem", j)
       if j != -1:
-        convert_TeX_brace_to_Argument(document, j, 2, 2, False, False)
-        j = j + 1
+        convert_TeX_brace_to_Argument(document, j, 2, 2, False, False, False)
+        j += 1
       if k != -1:
         k = find_token(document.body, "\\begin_layout Language", k)
       if k != -1:
-        convert_TeX_brace_to_Argument(document, k, 2, 6, False, False)
-        k = k + 1
+        convert_TeX_brace_to_Argument(document, k, 2, 6, False, False, False)
+        k += 1
       if m != -1:
         m = find_token(document.body, "\\begin_layout LastLanguage", m)
       if m != -1:
-        convert_TeX_brace_to_Argument(document, m, 2, 6, False, False)
-        m = m + 1
+        convert_TeX_brace_to_Argument(document, m, 2, 6, False, False, False)
+        m += 1
       if i == -1 and j == -1 and k == -1 and m == -1:
         return
 
@@ -1872,30 +1997,36 @@ def revert_ModernCV(document):
     k = 0
     m = 0
     o = 0
+    p = 0
     while True:
       if j != -1:
         j = find_token(document.body, "\\begin_layout Entry", j)
       if j != -1:
         revert_Argument_to_TeX_brace(document, j, 0, 1, 5, False, False)
-        j = j + 1
+        j += 1
       if k != -1:
         k = find_token(document.body, "\\begin_layout Item", k)
       if k != -1:
         revert_Argument_to_TeX_brace(document, k, 0, 1, 1, False, False)
-        k = k + 1
+        k += 1
       if m != -1:
         m = find_token(document.body, "\\begin_layout ItemWithComment", m)
       if m != -1:
         revert_Argument_to_TeX_brace(document, m, 0, 1, 2, False, False)
         document.body[m] = document.body[m].replace("\\begin_layout ItemWithComment", "\\begin_layout Language")
-        m = m + 1
+        m += 1
       if o != -1:
         o = find_token(document.body, "\\begin_layout DoubleItem", o)
       if o != -1:
         revert_Argument_to_TeX_brace(document, o, 0, 1, 3, False, False)
         document.body[o] = document.body[o].replace("\\begin_layout DoubleItem", "\\begin_layout Computer")
         o = o + 1
-      if j == -1 and k == -1 and m == -1 and o == -1:
+      if p != -1:
+        p = find_token(document.body, "\\begin_layout Social", p)
+      if p != -1:
+        revert_Argument_to_TeX_brace(document, p, 0, 1, 1, False, True)
+        p = p + 1
+      if j == -1 and k == -1 and m == -1 and o == -1 and p == -1:
         return
 
 
@@ -1905,21 +2036,19 @@ def revert_ModernCV_2(document):
     flex = 0
     flexEnd = -1
     while True:
-      if flex != -1:
-        flex = find_token(document.body, "\\begin_inset Flex Column", flex)
-      if flex != -1:
-        flexEnd = find_end_of_inset(document.body, flex)
-        wasOpt = revert_Argument_to_TeX_brace(document, flex, flexEnd, 1, 1, False, True)
-        revert_Argument_to_TeX_brace(document, flex, 0, 2, 2, False, False)
-        flexEnd = find_end_of_inset(document.body, flex)
-        if wasOpt == True:
-          document.body[flex + 0 : flex + 4] = put_cmd_in_ert("\\cvcolumn")
-        else:
-          document.body[flex + 0 : flex + 4] = put_cmd_in_ert("\\cvcolumn{")
-        document.body[flexEnd + 4 : flexEnd + 7] = put_cmd_in_ert("}")
-        flex = flex + 1
+      flex = find_token(document.body, "\\begin_inset Flex Column", flex)
       if flex == -1:
         return flexEnd
+      flexEnd = find_end_of_inset(document.body, flex)
+      wasOpt = revert_Argument_to_TeX_brace(document, flex, flexEnd, 1, 1, False, True)
+      revert_Argument_to_TeX_brace(document, flex, 0, 2, 2, False, False)
+      flexEnd = find_end_of_inset(document.body, flex)
+      if wasOpt == True:
+        document.body[flex + 0 : flex + 4] = put_cmd_in_ert("\\cvcolumn")
+      else:
+        document.body[flex + 0 : flex + 4] = put_cmd_in_ert("\\cvcolumn{")
+      document.body[flexEnd + 4 : flexEnd + 7] = put_cmd_in_ert("}")
+      flex += 1
 
 
 def revert_ModernCV_3(document):
@@ -1931,17 +2060,38 @@ def revert_ModernCV_3(document):
     # get the position of the end of the last column inset
     LastFlexEnd = revert_ModernCV_2(document)
     while True:
-      if p != -1:
-        p = find_token(document.body, "\\begin_layout Columns", p)
-      if p != -1:
-        pEnd = find_end_of_layout(document.body, p)
-        document.body[p] = document.body[p].replace("\\begin_layout Columns", "\\begin_layout Standard")
-        if LastFlexEnd != -1:
-          document.body[p + 1 : p + 1] = put_cmd_in_ert("\\begin{cvcolumns}")
-          document.body[LastFlexEnd + 24 : LastFlexEnd + 24] = put_cmd_in_ert("\\end{cvcolumns}")
-        p = p + 1
+      p = find_token(document.body, "\\begin_layout Columns", p)
       if p == -1:
         return
+      pEnd = find_end_of_layout(document.body, p)
+      document.body[p] = document.body[p].replace("\\begin_layout Columns", "\\begin_layout Standard")
+      if LastFlexEnd != -1:
+        document.body[p + 1 : p + 1] = put_cmd_in_ert("\\begin{cvcolumns}")
+        document.body[LastFlexEnd + 24 : LastFlexEnd + 24] = put_cmd_in_ert("\\end{cvcolumns}")
+      p += 1
+
+
+def revert_ModernCV_4(document):
+  " Reverts the style Social to TeX-code "
+  if document.textclass == "moderncv":
+    # revert the layouts
+    revert_ModernCV(document)
+    p = 0
+    while True:
+      p = find_token(document.body, "\\begin_layout Social", p)
+      if p == -1:
+        return
+      pEnd = find_end_of_layout(document.body, p)
+      document.body[p] = document.body[p].replace("\\begin_layout Social", "\\begin_layout Standard")
+      document.body[p + 1 : p + 1] = put_cmd_in_ert("\\social")
+      hasOpt = find_token(document.body, "[", p + 9)
+      if hasOpt < p + 18:
+        document.body[p + 30 : p + 30] = put_cmd_in_ert("{")
+        document.body[p + 41 : p + 41] = put_cmd_in_ert("}")
+      else:
+        document.body[p + 11 : p + 11] = put_cmd_in_ert("{")
+        document.body[p + 21 : p + 21] = put_cmd_in_ert("}")
+      p += 1
 
 
 def convert_ModernCV(document):
@@ -1956,24 +2106,24 @@ def convert_ModernCV(document):
       if i != -1:
         i = find_token(document.body, "\\begin_layout DoubleItem", i)
       if i != -1:
-        convert_TeX_brace_to_Argument(document, i, 1, 1, False, False)
+        convert_TeX_brace_to_Argument(document, i, 1, 1, False, False, False)
         document.body[o] = document.body[o].replace("\\begin_layout DoubleItem", "\\begin_layout DoubleListItem")
-        i = i + 1
+        i += 1
       if j != -1:
         j = find_token(document.body, "\\begin_layout Entry", j)
       if j != -1:
-        convert_TeX_brace_to_Argument(document, j, 1, 5, False, False)
-        j = j + 1
+        convert_TeX_brace_to_Argument(document, j, 1, 5, False, False, False)
+        j += 1
       if k != -1:
         k = find_token(document.body, "\\begin_layout Item", k)
       if k != -1:
-        convert_TeX_brace_to_Argument(document, k, 1, 1, False, False)
-        k = k + 1
+        convert_TeX_brace_to_Argument(document, k, 1, 1, False, False, False)
+        k += 1
       if m != -1:
         m = find_token(document.body, "\\begin_layout Language", m)
       if m != -1:
-        convert_TeX_brace_to_Argument(document, m, 1, 2, False, False)
-        m = m + 1
+        convert_TeX_brace_to_Argument(document, m, 1, 2, False, False, False)
+        m += 1
       if i == -1 and j == -1 and k == -1 and m == -1:
         return
 
@@ -1982,27 +2132,23 @@ def revert_Initials(document):
   " Reverts InsetArgument of Initial to TeX-code "
   i = 0
   while True:
-    if i != -1:
-      i = find_token(document.body, "\\begin_layout Initial", i)
-    if i != -1:
-      # first arg (optional) and second arg (first mandatory) are supported in LyX 2.0.x
-      revert_Argument_to_TeX_brace(document, i, 0, 3, 3, False, False)
-      i = i + 1
+    i = find_token(document.body, "\\begin_layout Initial", i)
     if i == -1:
       return
+    # first arg (optional) and second arg (first mandatory) are supported in LyX 2.0.x
+    revert_Argument_to_TeX_brace(document, i, 0, 3, 3, False, False)
+    i += 1
 
 
 def convert_Initials(document):
   " Converts ERT of Initial to InsetArgument "
   i = 0
   while True:
-    if i != -1:
-      i = find_token(document.body, "\\begin_layout Initial", i)
-    if i != -1:
-      convert_TeX_brace_to_Argument(document, i, 3, 3, False, False)
-      i = i + 1
+    i = find_token(document.body, "\\begin_layout Initial", i)
     if i == -1:
       return
+    convert_TeX_brace_to_Argument(document, i, 3, 3, False, False, False)
+    i += 1
 
 
 def revert_literate(document):
@@ -2015,12 +2161,12 @@ def revert_literate(document):
         if i == -1:
           break
         document.body[i] = "\\begin_layout Scrap"
-        i = i + 1
+        i += 1
 
 
 def convert_literate(document):
     " Convert Literate document to new format"
-    i = find_token(document.header, "\\textclass", 0)    
+    i = find_token(document.header, "\\textclass", 0)
     if (i != -1) and "literate-" in document.header[i]:
       document.textclass = document.header[i].replace("\\textclass literate-", "")
       j = find_token(document.header, "\\begin_modules", 0)
@@ -2036,7 +2182,7 @@ def convert_literate(document):
         if i == -1:
           break
         document.body[i] = "\\begin_layout Chunk"
-        i = i + 1
+        i += 1
 
 
 def revert_itemargs(document):
@@ -2051,7 +2197,7 @@ def revert_itemargs(document):
         parent = get_containing_layout(document.body, i)
         if parent == False:
             document.warning("Malformed LyX document: Can't find parent paragraph layout")
-            i = i + 1
+            i += 1
             continue
         parbeg = parent[3]
         beginPlain = find_token(document.body, "\\begin_layout Plain Layout", i)
@@ -2060,16 +2206,16 @@ def revert_itemargs(document):
         del document.body[i:j+1]
         subst = put_cmd_in_ert("[") + content + put_cmd_in_ert("]")
         document.body[parbeg : parbeg] = subst
-        i = i + 1
+        i += 1
 
 
 def revert_garamondx_newtxmath(document):
-    " Revert native garamond newtxmath definition to LaTeX " 
+    " Revert native garamond newtxmath definition to LaTeX "
 
     i = find_token(document.header, "\\font_math", 0)
     if i == -1:
        return
-    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: 
+    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
         val = get_value(document.header, "\\font_math", i)
         if val == "garamondx-ntxm":
             add_to_preamble(document, "\\usepackage[garamondx]{newtxmath}")
@@ -2077,9 +2223,9 @@ def revert_garamondx_newtxmath(document):
 
 
 def revert_garamondx(document):
-    " Revert native garamond font definition to LaTeX " 
+    " Revert native garamond font definition to LaTeX "
 
-    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: 
+    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
         i = find_token(document.header, "\\font_roman garamondx", 0)
         if i != -1:
             osf = False
@@ -2096,7 +2242,7 @@ def revert_garamondx(document):
 
 def convert_beamerargs(document):
     " Converts beamer arguments to new layout "
-    
+
     beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
     if document.textclass not in beamer_classes:
         return
@@ -2114,7 +2260,7 @@ def convert_beamerargs(document):
         parent = get_containing_layout(document.body, i)
         if parent == False:
             document.warning("Malformed LyX document: Can't find parent paragraph layout")
-            i = i + 1
+            i += 1
             continue
         parbeg = parent[1]
         parend = parent[2]
@@ -2152,21 +2298,122 @@ def convert_beamerargs(document):
                                 if document.body[p + 9].endswith(">"):
                                     # strip off the >
                                     document.body[p + 9] = document.body[p + 9][:-1]
+                        elif document.body[p + 4].startswith("<"):
+                            # This is an overlay specification (without ERT)
+                            # strip off the <
+                            document.body[p + 4] = document.body[p + 4][1:]
+                            if document.body[p + 4].endswith(">"):
+                                # strip off the >
+                                document.body[p + 4] = document.body[p + 4][:-1]
                         elif layoutname != "Itemize":
                             # Shift this one
                             document.body[p] = "\\begin_inset Argument 2"
-        i = i + 1
+        i += 1
+
+
+#
+# Helper function for the frame conversion routines
+#
+# FIXME: This method currently requires the arguments to be either
+#        * In one (whole) ERT each: <ERT>[<arg1>]</ERT><ERT><arg2></ERT><ERT>[arg3]</ERT>
+#        * Altogether in one whole ERT: <ERT>[<arg1>]<arg2>[arg3]</ERT>
+#        If individual arguments mix ERT and non-ERT or are splitted
+#        over several ERTs, the parsing fails.
+def convert_beamerframeargs(document, i, parbeg):
+    ertend = i
+    while True:
+        if document.body[parbeg] != "\\begin_inset ERT":
+            return ertend
+        ertend = find_end_of_inset(document.body, parbeg)
+        if ertend == -1:
+            document.warning("Malformed LyX document: missing ERT \\end_inset")
+            return ertend
+        ertcont = parbeg + 5
+        if document.body[ertcont].startswith("[<"):
+            # This is a default overlay specification
+            # strip off the [<
+            document.body[ertcont] = document.body[ertcont][2:]
+            if document.body[ertcont].endswith(">]"):
+                # strip off the >]
+                document.body[ertcont] = document.body[ertcont][:-2]
+            elif document.body[ertcont].endswith("]"):
+                # divide the args
+                tok = document.body[ertcont].find('>][')
+                if tok != -1:
+                    subst = [document.body[ertcont][:tok],
+                              '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 3',
+                              'status collapsed', '', '\\begin_layout Plain Layout',
+                              document.body[ertcont][tok + 3:-1]]
+                    document.body[ertcont : ertcont + 1] = subst
+                    ertend += 11
+            # Convert to ArgInset
+            document.body[parbeg] = "\\begin_inset Argument 2"
+        elif document.body[ertcont].startswith("<"):
+            # This is an overlay specification
+            # strip off the <
+            document.body[ertcont] = document.body[ertcont][1:]
+            if document.body[ertcont].endswith(">"):
+                # strip off the >
+                document.body[ertcont] = document.body[ertcont][:-1]
+                # Convert to ArgInset
+                document.body[parbeg] = "\\begin_inset Argument 1"
+            elif document.body[ertcont].endswith(">]"):
+                # divide the args
+                tok = document.body[ertcont].find('>[<')
+                if tok != -1:
+                    document.body[ertcont : ertcont + 1] = [document.body[ertcont][:tok],
+                                                    '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 2',
+                                                    'status collapsed', '', '\\begin_layout Plain Layout',
+                                                    document.body[ertcont][tok + 3:-2]]
+                # Convert to ArgInset
+                document.body[parbeg] = "\\begin_inset Argument 1"
+                ertend += 11
+            elif document.body[ertcont].endswith("]"):
+                # divide the args
+                tok = document.body[ertcont].find('>[<')
+                if tok != -1:
+                    # divide the args
+                    tokk = document.body[ertcont].find('>][')
+                    if tokk != -1:
+                        document.body[ertcont : ertcont + 1] = [document.body[ertcont][:tok],
+                                                        '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 2',
+                                                        'status collapsed', '', '\\begin_layout Plain Layout',
+                                                        document.body[ertcont][tok + 3:tokk],
+                                                        '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 3',
+                                                        'status collapsed', '', '\\begin_layout Plain Layout',
+                                                        document.body[ertcont][tokk + 3:-1]]
+                        ertend += 22
+                else:
+                    tokk = document.body[ertcont].find('>[')
+                    if tokk != -1:
+                        document.body[ertcont : ertcont + 1] = [document.body[ertcont][:tokk],
+                                                        '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 3',
+                                                        'status collapsed', '', '\\begin_layout Plain Layout',
+                                                        document.body[ertcont][tokk + 2:-1]]
+                        ertend += 11
+                # Convert to ArgInset
+                document.body[parbeg] = "\\begin_inset Argument 1"
+        elif document.body[ertcont].startswith("["):
+            # This is an ERT option
+            # strip off the [
+            document.body[ertcont] = document.body[ertcont][1:]
+            if document.body[ertcont].endswith("]"):
+                # strip off the ]
+                document.body[ertcont] = document.body[ertcont][:-1]
+                # Convert to ArgInset
+                document.body[parbeg] = "\\begin_inset Argument 3"
+        parbeg = ertend + 3
+        continue
+    return ertend
 
 
 def convert_againframe_args(document):
     " Converts beamer AgainFrame to new layout "
 
-    # FIXME: This currently only works if the arguments are in one single ERT
-    
     beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
     if document.textclass not in beamer_classes:
         return
-   
+
     i = 0
     while True:
         i = find_token(document.body, "\\begin_layout AgainFrame", i)
@@ -2178,93 +2425,21 @@ def convert_againframe_args(document):
         j = parent[2]
         parbeg = parent[3]
         if i != -1:
-            if document.body[parbeg] == "\\begin_inset ERT":
-                ertcont = parbeg + 5
-                if document.body[ertcont].startswith("[<"):
-                    # This is a default overlay specification
-                    # strip off the [<
-                    document.body[ertcont] = document.body[ertcont][2:]
-                    if document.body[ertcont].endswith(">]"):
-                        # strip off the >]
-                        document.body[ertcont] = document.body[ertcont][:-2]
-                    elif document.body[ertcont].endswith("]"):
-                        # divide the args
-                        tok = document.body[ertcont].find('>][')
-                        if tok != -1:
-                            subst = [document.body[ertcont][:tok],
-                                     '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 3',
-                                     'status collapsed', '', '\\begin_layout Plain Layout',
-                                     document.body[ertcont][tok + 3:-1]]
-                            document.body[ertcont : ertcont + 1] = subst
-                     # Convert to ArgInset
-                    document.body[parbeg] = "\\begin_inset Argument 2"
-                    i = j
-                    continue
-                elif document.body[ertcont].startswith("<"):
-                    # This is an overlay specification
-                    # strip off the <
-                    document.body[ertcont] = document.body[ertcont][1:]
-                    if document.body[ertcont].endswith(">"):
-                        # strip off the >
-                        document.body[ertcont] = document.body[ertcont][:-1]
-                        # Convert to ArgInset
-                        document.body[parbeg] = "\\begin_inset Argument 1"
-                    elif document.body[ertcont].endswith(">]"):
-                        # divide the args
-                        tok = document.body[ertcont].find('>[<')
-                        if tok != -1:
-                           document.body[ertcont : ertcont + 1] = [document.body[ertcont][:tok],
-                                                           '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 2',
-                                                           'status collapsed', '', '\\begin_layout Plain Layout',
-                                                           document.body[ertcont][tok + 3:-2]]
-                        # Convert to ArgInset
-                        document.body[parbeg] = "\\begin_inset Argument 1"
-                    elif document.body[ertcont].endswith("]"):
-                        # divide the args
-                        tok = document.body[ertcont].find('>[<')
-                        if tok != -1:
-                           # divide the args
-                           tokk = document.body[ertcont].find('>][')
-                           if tokk != -1:
-                               document.body[ertcont : ertcont + 1] = [document.body[ertcont][:tok],
-                                                               '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 2',
-                                                               'status collapsed', '', '\\begin_layout Plain Layout',
-                                                               document.body[ertcont][tok + 3:tokk],
-                                                               '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 3',
-                                                               'status collapsed', '', '\\begin_layout Plain Layout',
-                                                               document.body[ertcont][tokk + 3:-1]]
-                        else:
-                            tokk = document.body[ertcont].find('>[')
-                            if tokk != -1:
-                                document.body[ertcont : ertcont + 1] = [document.body[ertcont][:tokk],
-                                                                '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 3',
-                                                                'status collapsed', '', '\\begin_layout Plain Layout',
-                                                                document.body[ertcont][tokk + 2:-1]]
-                        # Convert to ArgInset
-                        document.body[parbeg] = "\\begin_inset Argument 1"
-                    i = j
-                    continue
-                elif document.body[ertcont].startswith("["):
-                    # This is an ERT option
-                    # strip off the [
-                    document.body[ertcont] = document.body[ertcont][1:]
-                    if document.body[ertcont].endswith("]"):
-                        # strip off the ]
-                        document.body[ertcont] = document.body[ertcont][:-1]
-                        # Convert to ArgInset
-                        document.body[parbeg] = "\\begin_inset Argument 3"
-                    i = j
-                    continue
+            # Convert ERT arguments
+            # FIXME: See restrictions in convert_beamerframeargs method
+            ertend = convert_beamerframeargs(document, i, parbeg)
+            if ertend == -1:
+                break
         i = j
 
 
 def convert_corollary_args(document):
     " Converts beamer corrolary-style ERT arguments native InsetArgs "
-    
+
     beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
     if document.textclass not in beamer_classes:
         return
-   
+
     corollary_layouts = ["Corollary", "Definition", "Definitions", "Example", "Examples", "Fact", "Proof", "Theorem"]
     for lay in corollary_layouts:
         i = 0
@@ -2279,37 +2454,70 @@ def convert_corollary_args(document):
             parbeg = parent[3]
             if i != -1:
                 if document.body[parbeg] == "\\begin_inset ERT":
-                    ertcont = parbeg + 5
-                    if document.body[ertcont].startswith("<"):
+                    ertcontfirstline = parbeg + 5
+                    # Find the last ERT in this paragraph (which might also be the first)
+                    lastertbeg = find_token_backwards(document.body, "\\begin_inset ERT", j)
+                    if lastertbeg == -1:
+                        document.warning("Last ERT not found!")
+                        break
+                    lastertend = find_end_of_inset(document.body, lastertbeg)
+                    if lastertend == -1:
+                        document.warning("End of last ERT not found!")
+                        break
+                    ertcontlastline = lastertend - 3
+                    if document.body[ertcontfirstline].startswith("<"):
                         # This is an overlay specification
                         # strip off the <
-                        document.body[ertcont] = document.body[ertcont][1:]
-                        if document.body[ertcont].endswith(">"):
+                        document.body[ertcontfirstline] = document.body[ertcontfirstline][1:]
+                        if document.body[ertcontlastline].endswith(">"):
                             # strip off the >
-                            document.body[ertcont] = document.body[ertcont][:-1]
-                        elif document.body[ertcont].endswith("]"):
+                            document.body[ertcontlastline] = document.body[ertcontlastline][:-1]
+                            if ertcontfirstline < ertcontlastline:
+                                # Multiline ERT. Might contain TeX code.  Embrace in ERT.
+                                document.body[ertcontlastline : ertcontlastline + 1] = [
+                                                                    document.body[ertcontlastline], '\\end_layout', '', '\\end_inset']
+                                document.body[ertcontfirstline : ertcontfirstline + 1] = [
+                                                                    '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 1',
+                                                                    'status collapsed', '', '\\begin_layout Plain Layout',
+                                                                    '\\begin_inset ERT', '', 'status open' '', '\\begin_layout Plain Layout',
+                                                                    document.body[ertcontfirstline]]
+                            else:
+                                # Convert to ArgInset
+                                document.body[parbeg] = "\\begin_inset Argument 1"
+                        elif document.body[ertcontlastline].endswith("]"):
                             # divide the args
-                            tok = document.body[ertcont].find('>[')
+                            tok = document.body[ertcontfirstline].find('>[')
                             if tok != -1:
-                                subst = [document.body[ertcont][:tok],
-                                         '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 2',
-                                         'status collapsed', '', '\\begin_layout Plain Layout',
-                                         document.body[ertcont][tok + 2:-1]]
-                                document.body[ertcont : ertcont + 1] = subst
-                        # Convert to ArgInset
-                        document.body[parbeg] = "\\begin_inset Argument 1"
+                                if ertcontfirstline < ertcontlastline:
+                                    # Multiline ERT. Might contain TeX code.  Embrace in ERT.
+                                    document.body[ertcontlastline : ertcontlastline + 1] = [
+                                                                        document.body[ertcontlastline], '\\end_layout', '', '\\end_inset']
+                                    document.body[ertcontfirstline : ertcontfirstline + 1] = [document.body[ertcontfirstline][:tok],
+                                                                        '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 2',
+                                                                        'status collapsed', '', '\\begin_layout Plain Layout',
+                                                                        '\\begin_inset ERT', '', 'status open' '', '\\begin_layout Plain Layout',
+                                                                        document.body[ertcontfirstline][tok + 2:-1]]
+                                else:
+                                    document.body[ertcontfirstline : ertcontfirstline + 1] = [document.body[ertcontfirstline][:tok],
+                                                                        '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 2',
+                                                                        'status collapsed', '', '\\begin_layout Plain Layout',
+                                                                        document.body[ertcontfirstline][tok + 2:-1]]
+                            # Convert to ArgInset
+                            document.body[parbeg] = "\\begin_inset Argument 1"
                         i = j
                         continue
-                    elif document.body[ertcont].startswith("["):
-                        # This is an ERT option
-                        # strip off the [
-                        document.body[ertcont] = document.body[ertcont][1:]
-                        if document.body[ertcont].endswith("]"):
+                    elif document.body[ertcontlastline].startswith("["):
+                        if document.body[ertcontlastline].endswith("]"):
+                            # This is an ERT option
+                            # strip off the [
+                            document.body[ertcontlastline] = document.body[ertcontlastline][1:]
                             # strip off the ]
-                            document.body[ertcont] = document.body[ertcont][:-1]
-                        # Convert to ArgInset
-                        document.body[parbeg] = "\\begin_inset Argument 2"
-                    i = j
+                            document.body[ertcontlastline] = document.body[ertcontlastline][:-1]
+                            # Convert to ArgInset
+                            document.body[parbeg] = "\\begin_inset Argument 2"
+                        else:
+                            convert_TeX_brace_to_Argument(document, i, 2, 2, False, True, True)
+                    i += 1
                     continue
             i = j
 
@@ -2317,11 +2525,11 @@ def convert_corollary_args(document):
 
 def convert_quote_args(document):
     " Converts beamer quote style ERT args to native InsetArgs "
-    
+
     beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
     if document.textclass not in beamer_classes:
         return
-   
+
     quote_layouts = ["Uncover", "Only", "Quotation", "Quote", "Verse"]
     for lay in quote_layouts:
         i = 0
@@ -2348,9 +2556,45 @@ def convert_quote_args(document):
             i = j
 
 
+def cleanup_beamerargs(document):
+    " Clean up empty ERTs (conversion artefacts) "
+
+    beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
+    if document.textclass not in beamer_classes:
+        return
+
+    i = 0
+    while True:
+        i = find_token(document.body, "\\begin_inset Argument", 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 Argument inset")
+            i += 1
+            continue
+        while True:
+            ertbeg = find_token(document.body, "\\begin_inset ERT", i, j)
+            if ertbeg == -1:
+                break
+            ertend = find_end_of_inset(document.body, ertbeg)
+            if ertend == -1:
+                document.warning("Malformed LyX document: Can't find end of ERT inset")
+                break
+            stripped = [line for line in document.body[ertbeg : ertend + 1] if line.strip()]
+            if len(stripped) == 5:
+                # This is an empty ERT
+                offset = len(document.body[ertbeg : ertend + 1])
+                del document.body[ertbeg : ertend + 1]
+                j = j - offset
+            else:
+                i = ertend
+        i += 1
+
+
 def revert_beamerargs(document):
     " Reverts beamer arguments to old layout "
-    
+
     beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
     if document.textclass not in beamer_classes:
         return
@@ -2371,7 +2615,7 @@ def revert_beamerargs(document):
         parent = get_containing_layout(document.body, i)
         if parent == False:
             document.warning("Malformed LyX document: Can't find parent paragraph layout")
-            i = i + 1
+            i += 1
             continue
         parbeg = parent[1]
         parend = parent[2]
@@ -2486,8 +2730,22 @@ def revert_beamerargs(document):
                         endPlain = find_end_of_layout(document.body, beginPlain)
                         content = document.body[beginPlain + 1 : endPlain]
                         del document.body[i:j+1]
-                        subst = put_cmd_in_ert("[") + content + put_cmd_in_ert("]")
-                        document.body[realparbeg : realparbeg] = subst
+                        if layoutname == "Description":
+                            # Description only has one (overlay) item arg
+                            subst = put_cmd_in_ert("<") + content + put_cmd_in_ert(">")
+                            # This must be put after the first space (begin of decription body
+                            # in LyX's arkward description list syntax)
+                            # Try to find that place ...
+                            rxx = re.compile(r'^([^\\ ]+ )(.*)$')
+                            for q in range(parbeg, parend):
+                                m = rxx.match(document.body[q])
+                                if m:
+                                    # We found it. Now insert the ERT argument just there:
+                                    document.body[q : q] = [m.group(1), ''] + subst + ['', m.group(2)]
+                                    break
+                        else:
+                            subst = put_cmd_in_ert("[") + content + put_cmd_in_ert("]")
+                            document.body[realparbeg : realparbeg] = subst
                     elif argnr == "item:2":
                         j = find_end_of_inset(document.body, i)
                         # Find containing paragraph layout
@@ -2527,13 +2785,13 @@ def revert_beamerargs(document):
                         del document.body[p : endInset + 1]
                         subst = put_cmd_in_ert("[") + content + put_cmd_in_ert("]")
                         document.body[realparbeg : realparbeg] = subst
-        
+
         i = realparend
 
 
 def revert_beamerargs2(document):
     " Reverts beamer arguments to old layout, step 2 "
-    
+
     beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
     if document.textclass not in beamer_classes:
         return
@@ -2551,7 +2809,7 @@ def revert_beamerargs2(document):
         parent = get_containing_layout(document.body, i)
         if parent == False:
             document.warning("Malformed LyX document: Can't find parent paragraph layout")
-            i = i + 1
+            i += 1
             continue
         parbeg = parent[1]
         parend = parent[2]
@@ -2567,7 +2825,7 @@ def revert_beamerargs2(document):
                 if m:
                     argnr = m.group(1)
                     if argnr == "2":
-                        document.body[p] = "\\begin_inset Argument 1"       
+                        document.body[p] = "\\begin_inset Argument 1"
             if layoutname in corollary_layouts:
                 m = rx.match(document.body[p])
                 if m:
@@ -2618,7 +2876,7 @@ def revert_beamerargs2(document):
 
 def revert_beamerargs3(document):
     " Reverts beamer arguments to old layout, step 3 "
-    
+
     beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
     if document.textclass not in beamer_classes:
         return
@@ -2633,7 +2891,7 @@ def revert_beamerargs3(document):
         parent = get_containing_layout(document.body, i)
         if parent == False:
             document.warning("Malformed LyX document: Can't find parent paragraph layout")
-            i = i + 1
+            i += 1
             continue
         parbeg = parent[1]
         parend = parent[2]
@@ -2664,7 +2922,7 @@ def revert_beamerargs3(document):
 
 def revert_beamerflex(document):
     " Reverts beamer Flex insets "
-    
+
     beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
     if document.textclass not in beamer_classes:
         return
@@ -2764,13 +3022,13 @@ def revert_beamerflex(document):
                 document.body[i : beginPlain + 1] = pre
                 post = put_cmd_in_ert("}")
                 document.body[z - 2 : z + 1] = post
-        
+
         i += 1
 
 
 def revert_beamerblocks(document):
     " Reverts beamer block arguments to ERT "
-    
+
     beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
     if document.textclass not in beamer_classes:
         return
@@ -2787,7 +3045,7 @@ def revert_beamerblocks(document):
         parent = get_containing_layout(document.body, i)
         if parent == False:
             document.warning("Malformed LyX document: Can't find parent paragraph layout")
-            i = i + 1
+            i += 1
             continue
         parbeg = parent[1]
         parend = parent[2]
@@ -2830,11 +3088,11 @@ def revert_beamerblocks(document):
 
 def convert_beamerblocks(document):
     " Converts beamer block ERT args to native InsetArgs "
-    
+
     beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
     if document.textclass not in beamer_classes:
         return
-   
+
     blocks = ["Block", "ExampleBlock", "AlertBlock"]
     for lay in blocks:
         i = 0
@@ -2847,43 +3105,219 @@ def convert_beamerblocks(document):
                 document.warning("Wrong parent layout!")
                 i += 1
                 continue
-            j = parent[2]
             parbeg = parent[3]
+            parend = parent[2]
+            j = parend
             if i != -1:
+                # If the paragraph starts with a language switch, adjust parbeg
+                if len(document.body[parbeg]) == 0 and parbeg < parend \
+                and document.body[parbeg + 1].startswith("\\lang"):
+                    parbeg += 2
                 if document.body[parbeg] == "\\begin_inset ERT":
-                    ertcont = parbeg + 5
+                    ertcontfirstline = parbeg + 5
+                    lastertbeg = -1
+                    lastertend = -1
+                    while True:
+                        # Find the last ERT in this paragraph used for arguments
+                        # (which might also be the first)
+                        lastertbeg = find_token_backwards(document.body, "\\begin_inset ERT", j)
+                        if lastertbeg == -1:
+                            document.warning("Last ERT not found!")
+                            break
+                        lastertend = find_end_of_inset(document.body, lastertbeg)
+                        if lastertend == -1:
+                            document.warning("End of last ERT not found!")
+                            break
+                        # Is this ERT really used for an argument?
+                        # Note: This will fail when non-argument ERTs actually use brackets
+                        #       (e.g. \pause{})
+                        regexp = re.compile(r'.*[>\]\}]', re.IGNORECASE)
+                        cbracket = find_re(document.body, regexp, lastertbeg, lastertend)
+                        if cbracket != -1:
+                            break
+                        if lastertbeg == parbeg:
+                            break
+                        j = lastertbeg - 1
+                    if lastertbeg == -1 or lastertend == -1:
+                        break
+                    ertcontlastline = lastertend - 3
                     while True:
-                        if document.body[ertcont].startswith("<"):
+                        if document.body[ertcontfirstline].lstrip().startswith("<"):
                             # This is an overlay specification
                             # strip off the <
-                            document.body[ertcont] = document.body[ertcont][1:]
-                            if document.body[ertcont].endswith(">"):
+                            document.body[ertcontfirstline] = document.body[ertcontfirstline].lstrip()[1:]
+                            if document.body[ertcontlastline].rstrip().endswith(">"):
                                 # strip off the >
-                                document.body[ertcont] = document.body[ertcont][:-1]
+                                document.body[ertcontlastline] = document.body[ertcontlastline].rstrip()[:-1]
                                 # Convert to ArgInset
                                 document.body[parbeg] = "\\begin_inset Argument 1"
-                            elif document.body[ertcont].endswith("}"):
+                            elif document.body[ertcontlastline].rstrip().endswith("}"):
+                                # strip off the }
+                                document.body[ertcontlastline] = document.body[ertcontlastline].rstrip()[:-1]
                                 # divide the args
-                                tok = document.body[ertcont].find('>{')
+                                ertcontdivline = ertcontfirstline
+                                tok = document.body[ertcontdivline].find('>{')
+                                if tok == -1:
+                                    regexp = re.compile(r'.*>\{', re.IGNORECASE)
+                                    ertcontdivline = find_re(document.body, regexp, ertcontfirstline, lastertend)
+                                    tok = document.body[ertcontdivline].find('>{')
                                 if tok != -1:
-                                    document.body[ertcont : ertcont + 1] = [document.body[ertcont][:tok],
+                                    if ertcontfirstline < ertcontlastline:
+                                        # Multiline ERT. Might contain TeX code.  Embrace in ERT.
+                                        document.body[ertcontlastline : ertcontlastline + 1] = [
+                                                                            document.body[ertcontlastline], '\\end_layout', '', '\\end_inset']
+                                        if ertcontdivline == ertcontfirstline:
+                                            document.body[ertcontdivline : ertcontdivline + 1] = [document.body[ertcontdivline][:tok],
+                                                                                '\\end_layout', '', '\\end_inset', '',
+                                                                                '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 2',
+                                                                                'status collapsed', '', '\\begin_layout Plain Layout',
+                                                                                '\\begin_inset ERT', '', 'status open' '', '\\begin_layout Plain Layout',
+                                                                                document.body[ertcontdivline][tok + 2:]]
+                                        else:
+                                            document.body[ertcontdivline : ertcontdivline + 1] = [document.body[ertcontdivline][:tok],
+                                                                                '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 2',
+                                                                                'status collapsed', '', '\\begin_layout Plain Layout',
+                                                                                '\\begin_inset ERT', '', 'status open' '', '\\begin_layout Plain Layout',
+                                                                                document.body[ertcontdivline][tok + 2:]]
+                                    else:
+                                        document.body[ertcontdivline : ertcontdivline + 1] = [document.body[ertcontdivline][:tok],
                                                                             '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 2',
                                                                             'status collapsed', '', '\\begin_layout Plain Layout',
-                                                                            document.body[ertcont][tok + 2:-1]]
-                            # Convert to ArgInset
-                            document.body[parbeg] = "\\begin_inset Argument 1"
-                        elif document.body[ertcont].startswith("{"):
+                                                                            document.body[ertcontdivline][tok + 2:]]
+                                else:
+                                    # check if have delimiters in two different ERTs
+                                    tok = document.body[ertcontdivline].find('>')
+                                    if tok == -1:
+                                        regexp = re.compile(r'.*>', re.IGNORECASE)
+                                        ertcontdivline = find_re(document.body, regexp, ertcontfirstline, lastertend)
+                                        tok = document.body[ertcontdivline].find('>')
+                                    if tok != -1:
+                                        tokk = document.body[ertcontdivline].find('{')
+                                        if tokk == -1:
+                                            regexp = re.compile(r'.*\{', re.IGNORECASE)
+                                            ertcontdivlinetwo = find_re(document.body, regexp, ertcontfirstline, lastertend)
+                                            tokk = document.body[ertcontdivlinetwo].find('{')
+                                        if tokk != -1:
+                                            if ertcontfirstline < ertcontlastline:
+                                                # Multiline ERT. Might contain TeX code.  Embrace in ERT.
+                                                document.body[ertcontlastline : ertcontlastline + 1] = [
+                                                                                    document.body[ertcontlastline], '\\end_layout', '', '\\end_inset']
+                                                document.body[ertcontdivline : ertcontdivlinetwo + 1] = [document.body[ertcontdivline][:tok],
+                                                                                    '\\end_layout', '', '\\end_inset', '', '\\end_layout', '',
+                                                                                    '\\end_inset', '', '', '\\begin_inset Argument 2',
+                                                                                    'status collapsed', '', '\\begin_layout Plain Layout',
+                                                                                    '\\begin_inset ERT', '', 'status open' '', '\\begin_layout Plain Layout',
+                                                                                    document.body[ertcontdivlinetwo][tokk + 1:]]
+                                            else:
+                                                document.body[ertcontdivline : ertcontdivlinetwo + 1] = [document.body[ertcontdivline][:tok],
+                                                                                    '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 2',
+                                                                                    'status collapsed', '', '\\begin_layout Plain Layout',
+                                                                                    document.body[ertcontdivlinetwo][tokk + 1:]]
+                                # Convert to ArgInset
+                                if ertcontfirstline < ertcontlastline:
+                                    # Multiline ERT. Might contain TeX code.  Embrace in ERT.
+                                    document.body[parbeg : parbeg + 1] = ['\\begin_inset Argument 1',
+                                                                        'status collapsed', '', '\\begin_layout Plain Layout',
+                                                                        '\\begin_inset ERT', '']
+                                else:
+                                    document.body[parbeg] = "\\begin_inset Argument 1"
+                        elif document.body[ertcontfirstline].lstrip().startswith("{"):
                             # This is the block title
-                            if document.body[ertcont].endswith("}"):
+                            if document.body[ertcontlastline].rstrip().endswith("}"):
                                 # strip off the braces
-                                document.body[ertcont] = document.body[ertcont][1:-1]
+                                document.body[ertcontfirstline] = document.body[ertcontfirstline].lstrip()[1:]
+                                document.body[ertcontlastline] = document.body[ertcontlastline].rstrip()[:-1]
+                                if ertcontfirstline < ertcontlastline:
+                                    # Multiline ERT. Might contain TeX code.  Embrace in ERT.
+                                    document.body[parend : parend + 1] = [
+                                                                        document.body[parend], '\\end_inset', '', '\\end_layout']
+                                    document.body[parbeg : parbeg + 1] = ['\\begin_inset Argument 2',
+                                                                        'status collapsed', '', '\\begin_layout Plain Layout',
+                                                                        '\\begin_inset ERT', '']
+                                else:
+                                    # Convert to ArgInset
+                                    document.body[parbeg] = "\\begin_inset Argument 2"
+                            # the overlay argument can also follow the title, so ...
+                            elif document.body[ertcontlastline].rstrip().endswith(">"):
+                                # strip off the {
+                                document.body[ertcontfirstline] = document.body[ertcontfirstline].lstrip()[1:]
+                                # strip off the >
+                                document.body[ertcontlastline] = document.body[ertcontlastline].rstrip()[:-1]
+                                # divide the args
+                                ertcontdivline = ertcontfirstline
+                                tok = document.body[ertcontdivline].find('}<')
+                                if tok == -1:
+                                    regexp = re.compile(r'.*\}<', re.IGNORECASE)
+                                    ertcontdivline = find_re(document.body, regexp, ertcontfirstline, lastertend)
+                                    tok = document.body[ertcontdivline].find('}<')
+                                if tok != -1:
+                                    if ertcontfirstline < ertcontlastline:
+                                        # Multiline ERT. Might contain TeX code.  Embrace in ERT.
+                                        document.body[ertcontlastline : ertcontlastline + 1] = [
+                                                                            document.body[ertcontlastline], '\\end_layout', '', '\\end_inset']
+                                        if ertcontdivline == ertcontfirstline:
+                                            document.body[ertcontdivline : ertcontdivline + 1] = [document.body[ertcontdivline][:tok],
+                                                                                '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 1',
+                                                                                'status collapsed', '', '\\begin_layout Plain Layout',
+                                                                                '\\begin_inset ERT', '', 'status open' '', '\\begin_layout Plain Layout',
+                                                                                document.body[ertcontdivline][tok + 2:]]
+                                        else:
+                                            document.body[ertcontdivline : ertcontdivline + 1] = [document.body[ertcontdivline][:tok],
+                                                                                '\\end_layout', '', '\\end_inset', '',
+                                                                                '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 1',
+                                                                                'status collapsed', '', '\\begin_layout Plain Layout',
+                                                                                '\\begin_inset ERT', '', 'status open' '', '\\begin_layout Plain Layout',
+                                                                                document.body[ertcontdivline][tok + 2:]]
+                                    else:
+                                        document.body[ertcontdivline : ertcontdivline + 1] = [document.body[ertcontdivline][:tok],
+                                                                            '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 1',
+                                                                            'status collapsed', '', '\\begin_layout Plain Layout',
+                                                                            document.body[ertcontdivline][tok + 2:]]
+                                else:
+                                    # check if have delimiters in two different ERTs
+                                    tok = document.body[ertcontdivline].find('}')
+                                    if tok == -1:
+                                        regexp = re.compile(r'.*\}', re.IGNORECASE)
+                                        ertcontdivline = find_re(document.body, regexp, ertcontfirstline, lastertend)
+                                        tok = document.body[ertcontdivline].find('}')
+                                        if tok != -1:
+                                            tokk = document.body[ertcontdivline].find('<')
+                                            if tokk == -1:
+                                                regexp = re.compile(r'.*<', re.IGNORECASE)
+                                                ertcontdivlinetwo = find_re(document.body, regexp, ertcontfirstline, lastertend)
+                                                tokk = document.body[ertcontdivlinetwo].find('<')
+                                                if tokk != -1:
+                                                    if ertcontfirstline < ertcontlastline:
+                                                        # Multiline ERT. Might contain TeX code.  Embrace in ERT.
+                                                        document.body[ertcontlastline : ertcontlastline + 1] = [
+                                                                                            document.body[ertcontlastline], '\\end_layout', '', '\\end_inset']
+                                                        document.body[ertcontdivline : ertcontdivlinetwo + 1] = [document.body[ertcontdivline][:tok],
+                                                                                            '\\end_layout', '', '\\end_inset', '', '\\end_layout', '',
+                                                                                            '\\end_inset', '', '', '\\begin_inset Argument 1',
+                                                                                            'status collapsed', '', '\\begin_layout Plain Layout',
+                                                                                            '\\begin_inset ERT', '', 'status open' '', '\\begin_layout Plain Layout',
+                                                                                            document.body[ertcontdivlinetwo][tokk + 1:]]
+                                                    else:
+                                                        document.body[ertcontdivline : ertcontdivlinetwo + 1] = [document.body[ertcontdivline][:tok],
+                                                                                            '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 1',
+                                                                                            'status collapsed', '', '\\begin_layout Plain Layout',
+                                                                                            document.body[ertcontdivlinetwo][tokk + 1:]]
                                 # Convert to ArgInset
-                                document.body[parbeg] = "\\begin_inset Argument 2"
-                            elif count_pars_in_inset(document.body, ertcont) > 1:
+                                if ertcontfirstline < ertcontlastline:
+                                    # Multiline ERT. Might contain TeX code.  Embrace in ERT.
+                                    document.body[parbeg : parbeg + 1] = ['\\begin_inset Argument 2',
+                                                                        'status collapsed', '', '\\begin_layout Plain Layout',
+                                                                        '\\begin_inset ERT', '']
+                                else:
+                                    document.body[parbeg] = "\\begin_inset Argument 2"
+                            elif count_pars_in_inset(document.body, ertcontfirstline) > 1:
                                 # Multipar ERT. Skip this.
                                 break
                             else:
-                                convert_TeX_brace_to_Argument(document, i, 2, 2, False, True)
+                                # ERT has contents after the closing bracket. We cannot convert this.
+                                # convert_TeX_brace_to_Argument cannot either.
+                                #convert_TeX_brace_to_Argument(document, i, 2, 2, False, True, False)
+                                break
                         else:
                             break
                         j = find_end_of_layout(document.body, i)
@@ -2897,14 +3331,14 @@ def convert_beamerblocks(document):
                         m = find_token(document.body, "\\begin_inset ERT", l, j)
                         if m == -1:
                             break
-                        ertcont = m + 5
+                        ertcontfirstline = m + 5
                         parbeg = m
             i = j
 
 
 def convert_overprint(document):
     " Convert old beamer overprint layouts to ERT "
-    
+
     beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
     if document.textclass not in beamer_classes:
         return
@@ -2918,7 +3352,7 @@ def convert_overprint(document):
         j = find_end_of_sequence(document.body, i)
         if j == -1:
             document.warning("Malformed LyX document. Cannot find end of Overprint sequence!")
-            i = i + 1
+            i += 1
             continue
         endseq = j
         subst = ["\\begin_layout Standard"] + put_cmd_in_ert("\\begin{overprint}")
@@ -2934,7 +3368,7 @@ def convert_overprint(document):
             argend = find_end_of_layout(document.body, argbeg)
             if argend == -1:
                 document.warning("Malformed LyX document. Cannot find end of Overprint argument!")
-                i = i + 1
+                i += 1
                 continue
             beginPlain = find_token(document.body, "\\begin_layout Plain Layout", argbeg)
             endPlain = find_end_of_layout(document.body, beginPlain)
@@ -2944,11 +3378,11 @@ def convert_overprint(document):
             # Remove arg inset
             del document.body[argbeg : argend + 1]
             subst += put_cmd_in_ert("[") + content + put_cmd_in_ert("]")
-            
+
         endseq = endseq - len(document.body[i : i])
         document.body[i : i] = subst + ["\\end_layout"]
         endseq += len(subst)
-        
+
         for p in range(i, endseq):
             if document.body[p] == "\\begin_layout Overprint":
                 document.body[p] = "\\begin_layout Standard"
@@ -2958,7 +3392,7 @@ def convert_overprint(document):
 
 def revert_overprint(document):
     " Revert old beamer overprint layouts to ERT "
-    
+
     beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
     if document.textclass not in beamer_classes:
         return
@@ -2972,16 +3406,16 @@ def revert_overprint(document):
         j = find_end_of_sequence(document.body, i)
         if j == -1:
             document.warning("Malformed LyX document. Cannot find end of Overprint sequence!")
-            i = i + 1
+            i += 1
             continue
         endseq = j
         subst = ["\\begin_layout Standard"] + put_cmd_in_ert("\\begin{overprint}")
-        esubst = ["\\end_layout", "", "\\begin_layout Standard"] + put_cmd_in_ert("\\end{overprint}")
+        esubst = ["\\begin_layout Standard"] + put_cmd_in_ert("\\end{overprint}")
         endseq = endseq + len(esubst) - len(document.body[j : j])
         if document.body[j] == "\\end_deeper":
-            document.body[j : j] = ["\\end_deeper", ""] + esubst
+            document.body[j : j] = [""] + esubst + ["", "\\end_layout"]
         else:
-            document.body[j : j] = esubst
+            document.body[j : j] = ["\\end_layout", ""] + esubst
         r = i
         while r < j:
             if document.body[r] == "\\begin_deeper":
@@ -2994,24 +3428,27 @@ def revert_overprint(document):
             r = r + 1
         argbeg = find_token(document.body, "\\begin_inset Argument 1", i, j)
         if argbeg != -1:
-            argend = find_end_of_inset(document.body, argbeg)
-            if argend == -1:
-                document.warning("Malformed LyX document. Cannot find end of Overprint argument!")
-                i = i + 1
-                continue
-            beginPlain = find_token(document.body, "\\begin_layout Plain Layout", argbeg)
-            endPlain = find_end_of_layout(document.body, beginPlain)
-            content = document.body[beginPlain + 1 : endPlain]
-            # Adjust range end
-            endseq = endseq - len(document.body[argbeg : argend])
-            # Remove arg inset
-            del document.body[argbeg : argend + 1]
-            subst += put_cmd_in_ert("[") + content + put_cmd_in_ert("]")
-            
+            # Is this really our argument?
+            nested = find_token(document.body, "\\begin_deeper", i, argbeg)
+            if nested != -1:
+                argend = find_end_of_inset(document.body, argbeg)
+                if argend == -1:
+                    document.warning("Malformed LyX document. Cannot find end of Overprint argument!")
+                    i += 1
+                    continue
+                beginPlain = find_token(document.body, "\\begin_layout Plain Layout", argbeg)
+                endPlain = find_end_of_layout(document.body, beginPlain)
+                content = document.body[beginPlain + 1 : endPlain]
+                # Adjust range end
+                endseq = endseq - len(document.body[argbeg : argend])
+                # Remove arg inset
+                del document.body[argbeg : argend + 1]
+                subst += put_cmd_in_ert("[") + content + put_cmd_in_ert("]")
+
         endseq = endseq - len(document.body[i : i])
         document.body[i : i] = subst + ["\\end_layout"]
         endseq += len(subst)
-     
+
         p = i
         while True:
             if p >= endseq:
@@ -3047,7 +3484,7 @@ def revert_overprint(document):
 
 def revert_frametitle(document):
     " Reverts beamer frametitle layout to ERT "
-    
+
     beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
     if document.textclass not in beamer_classes:
         return
@@ -3061,7 +3498,7 @@ def revert_frametitle(document):
         j = find_end_of_layout(document.body, i)
         if j == -1:
             document.warning("Malformed LyX document: Can't find end of FrameTitle layout")
-            i = i + 1
+            i += 1
             continue
         endlay = j
         document.body[j : j] = put_cmd_in_ert("}") + document.body[j : j]
@@ -3093,7 +3530,7 @@ def revert_frametitle(document):
                     # Remove arg inset
                     del document.body[p : endInset + 1]
                     subst += put_cmd_in_ert("[") + content + put_cmd_in_ert("]")
-                    
+
         subst += put_cmd_in_ert("{")
         document.body[i : i + 1] = subst
         i = endlay
@@ -3101,7 +3538,7 @@ def revert_frametitle(document):
 
 def convert_epigraph(document):
     " Converts memoir epigraph to new syntax "
-    
+
     if document.textclass != "memoir":
         return
 
@@ -3113,7 +3550,7 @@ def convert_epigraph(document):
         j = find_end_of_layout(document.body, i)
         if j == -1:
             document.warning("Malformed LyX document: Can't find end of Epigraph layout")
-            i = i + 1
+            i += 1
             continue
         endlay = j
         subst = list()
@@ -3136,13 +3573,13 @@ def convert_epigraph(document):
                 endlay += len(begsubst) + len(endsubst)
                 endlay = endlay - len(document.body[ert : endInset + 1])
                 del document.body[ert : endInset + 1]
-                    
+
         i = endlay
 
 
 def revert_epigraph(document):
     " Reverts memoir epigraph argument to ERT "
-    
+
     if document.textclass != "memoir":
         return
 
@@ -3154,7 +3591,7 @@ def revert_epigraph(document):
         j = find_end_of_layout(document.body, i)
         if j == -1:
             document.warning("Malformed LyX document: Can't find end of Epigraph layout")
-            i = i + 1
+            i += 1
             continue
         endlay = j
         subst = list()
@@ -3171,33 +3608,33 @@ def revert_epigraph(document):
             subst += put_cmd_in_ert("}{") + content
         else:
             subst += put_cmd_in_ert("}{")
-                    
+
         document.body[j : j] = subst + document.body[j : j]
         i = endlay
 
 
 def convert_captioninsets(document):
     " Converts caption insets to new syntax "
-    
+
     i = 0
     while True:
       i = find_token(document.body, "\\begin_inset Caption", i)
       if i == -1:
           return
       document.body[i] = "\\begin_inset Caption Standard"
-      i = i + 1
+      i += 1
 
 
 def revert_captioninsets(document):
     " Reverts caption insets to old syntax "
-    
+
     i = 0
     while True:
       i = find_token(document.body, "\\begin_inset Caption Standard", i)
       if i == -1:
           return
       document.body[i] = "\\begin_inset Caption"
-      i = i + 1
+      i += 1
 
 
 def convert_captionlayouts(document):
@@ -3212,28 +3649,27 @@ def convert_captionlayouts(document):
         "Bicaption" : "Bicaption",
         }
 
-    i = 0
-    while True:
-        i = find_token(document.body, "\\begin_layout", i)
-        if i == -1:
-            return
-        val = get_value(document.body, "\\begin_layout", i)
-        if val in caption_dict.keys():
+    for captype in caption_dict.keys():
+        i = 0
+        while True:
+            i = find_token(document.body, "\\begin_layout " + captype, i)
+            if i == -1:
+                break
             j = find_end_of_layout(document.body, i)
             if j == -1:
                 document.warning("Malformed LyX document: Missing `\\end_layout'.")
-                return
+                break
 
             document.body[j:j] = ["\\end_layout", "", "\\end_inset", "", ""]
             document.body[i:i+1] = ["\\begin_layout %s" % document.default_layout,
-                                    "\\begin_inset Caption %s" % caption_dict[val], "",
+                                    "\\begin_inset Caption %s" % caption_dict[captype], "",
                                     "\\begin_layout %s" % document.default_layout]
-        i = i + 1
+            i = j + 1
 
 
 def revert_captionlayouts(document):
     " Revert caption insets to caption layouts. "
-    
+
     caption_dict = {
         "Above" : "Captionabove",
         "Below" : "Captionbelow",
@@ -3242,7 +3678,7 @@ def revert_captionlayouts(document):
         "Centered" : "CenteredCaption",
         "Bicaption" : "Bicaption",
         }
-    
+
     i = 0
     rx = re.compile(r'^\\begin_inset Caption (\S+)$')
     while True:
@@ -3254,10 +3690,10 @@ def revert_captionlayouts(document):
         val = ""
         if m:
             val = m.group(1)
-        if val not in caption_dict.keys():
-            i = i + 1
+        if val not in list(caption_dict.keys()):
+            i += 1
             continue
-        
+
         # We either need to delete the previous \begin_layout line, or we
         # need to end the previous layout if this inset is not in the first
         # position of the paragraph.
@@ -3320,12 +3756,12 @@ def revert_captionlayouts(document):
         document.body[i] = "\\begin_layout %s" % caption_dict[val]
         if document.body[i+1] == "":
             del document.body[i+1]
-        i = i + 1
+        i += 1
 
 
 def revert_fragileframe(document):
     " Reverts beamer FragileFrame layout to ERT "
-    
+
     beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
     if document.textclass not in beamer_classes:
         return
@@ -3339,14 +3775,14 @@ def revert_fragileframe(document):
         j = find_end_of_sequence(document.body, i)
         if j == -1:
             document.warning("Malformed LyX document. Cannot find end of FragileFrame sequence!")
-            i = i + 1
+            i += 1
             continue
         endseq = j
         subst = ["\\begin_layout Standard"] + put_cmd_in_ert("\\begin{frame}")
-        esubst = ["\\end_layout", "", "\\begin_layout Standard"] + put_cmd_in_ert("\\end{frame}")
+        esubst = ["\\begin_layout Standard"] + put_cmd_in_ert("\\end{frame}")
         endseq = endseq + len(esubst) - len(document.body[j : j])
         if document.body[j] == "\\end_deeper":
-            document.body[j : j] = ["\\end_deeper", ""] + esubst
+            document.body[j : j] = [""] + esubst + ["", "\\end_layout"]
         else:
             document.body[j : j] = esubst
         for q in range(i, j):
@@ -3407,14 +3843,14 @@ def revert_fragileframe(document):
                     subst += put_cmd_in_ert("{") + content + put_cmd_in_ert("}")
             elif p == 3:
                 subst += put_cmd_in_ert("[fragile]")
-                    
+
         document.body[i : i + 1] = subst
         i = j
 
 
 def revert_newframes(document):
     " Reverts beamer Frame and PlainFrame layouts to old forms "
-    
+
     beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
     if document.textclass not in beamer_classes:
         return
@@ -3435,23 +3871,23 @@ def revert_newframes(document):
         val = ""
         if m:
             val = m.group(1)
-        if val not in frame_dict.keys():
-            i = i + 1
+        if val not in list(frame_dict.keys()):
+            i += 1
             continue
         # Find end of sequence
         j = find_end_of_sequence(document.body, i)
         if j == -1:
             document.warning("Malformed LyX document. Cannot find end of Frame sequence!")
-            i = i + 1
+            i += 1
             continue
         endseq = j
         subst = ["\\begin_layout %s" % frame_dict[val]]
-        esubst = ["\\end_layout", "", "\\begin_layout EndFrame", "", "\\end_layout"]
+        esubst = ["", "\\begin_layout EndFrame", "", "\\end_layout"]
         endseq = endseq + len(esubst) - len(document.body[j : j])
         if document.body[j] == "\\end_deeper":
-            document.body[j : j] = ["\\end_deeper", ""] + esubst
-        else:
             document.body[j : j] = esubst
+        else:
+            document.body[j+1 : j+1] = esubst
         for q in range(i, j):
             if document.body[q] == "\\begin_layout %s" % val:
                 document.body[q] = "\\begin_layout %s" % document.default_layout
@@ -3509,7 +3945,7 @@ def revert_newframes(document):
                     # Remove arg inset
                     del document.body[arg : endInset + 1]
                     subst += content
-                    
+
         document.body[i : i + 1] = subst
         i = j
 
@@ -3551,7 +3987,7 @@ def convert_encodings(document):
     if i == -1:
         return
     val = get_value(document.header, "\\inputencoding", i)
-    if val in LaTeX2LyX_enc_dict.keys():
+    if val in list(LaTeX2LyX_enc_dict.keys()):
         document.header[i] = "\\inputencoding %s" % LaTeX2LyX_enc_dict[val]
     elif val not in known_enc_tuple:
         document.warning("Ignoring unknown input encoding: `%s'" % val)
@@ -3592,7 +4028,7 @@ def revert_encodings(document):
     if i == -1:
         return
     val = get_value(document.header, "\\inputencoding", i)
-    if val in LyX2LaTeX_enc_dict.keys():
+    if val in list(LyX2LaTeX_enc_dict.keys()):
         document.header[i] = "\\inputencoding %s" % LyX2LaTeX_enc_dict[val]
     elif val not in known_enc_tuple:
         document.warning("Ignoring unknown input encoding: `%s'" % val)
@@ -3634,18 +4070,18 @@ def revert_IEEEtran_3(document):
 
 def revert_kurier_fonts(document):
   " Revert kurier font definition to LaTeX "
-  
+
   i = find_token(document.header, "\\font_math", 0)
   if i != -1:
-    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: 
+    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
       val = get_value(document.header, "\\font_math", i)
       if val == "kurier-math":
         add_to_preamble(document, "\\let\\Myrmdefault\\rmdefault\n" \
           "\\usepackage[math]{kurier}\n" \
           "\\renewcommand{\\rmdefault}{\\Myrmdefault}")
         document.header[i] = "\\font_math auto"
-  
-  if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: 
+
+  if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
     kurier_fonts = ["kurier", "kurierc", "kurierl", "kurierlc"]
     k = find_token(document.header, "\\font_sans kurier", 0)
     if k != -1:
@@ -3656,18 +4092,18 @@ def revert_kurier_fonts(document):
 
 def revert_iwona_fonts(document):
   " Revert iwona font definition to LaTeX "
-  
+
   i = find_token(document.header, "\\font_math", 0)
   if i != -1:
-    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: 
+    if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
       val = get_value(document.header, "\\font_math", i)
       if val == "iwona-math":
         add_to_preamble(document, "\\let\\Myrmdefault\\rmdefault\n" \
           "\\usepackage[math]{iwona}\n" \
           "\\renewcommand{\\rmdefault}{\\Myrmdefault}")
         document.header[i] = "\\font_math auto"
-  
-  if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1: 
+
+  if find_token(document.header, "\\use_non_tex_fonts false", 0) != -1:
     iwona_fonts = ["iwona", "iwonac", "iwonal", "iwonalc"]
     k = find_token(document.header, "\\font_sans iwona", 0)
     if k != -1:
@@ -3679,7 +4115,7 @@ def revert_iwona_fonts(document):
 
 def revert_new_libertines(document):
     " Revert new libertine font definition to LaTeX "
-  
+
     if find_token(document.header, "\\use_non_tex_fonts true", 0) != -1:
         return
 
@@ -3695,7 +4131,7 @@ def revert_new_libertines(document):
         preamble += "{libertineMono-type1}"
         add_to_preamble(document, [preamble])
         document.header[i] = "\\font_typewriter default"
-   
+
     k = find_token(document.header, "\\font_sans biolinum", 0)
     if k != -1:
         preamble = "\\usepackage"
@@ -3720,14 +4156,14 @@ def revert_new_libertines(document):
 
 def convert_lyxframes(document):
     " Converts old beamer frames to new style "
-    
+
     beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
     if document.textclass not in beamer_classes:
         return
-   
+
     framebeg = ["BeginFrame", "BeginPlainFrame"]
-    frameend = ["EndFrame", "BeginFrame", "BeginPlainFrame", "AgainFrame", "Section", "Section*",
-                "Subsection", "Subsection*", "Subsubsection", "Subsubsection*"]
+    frameend = ["Frame", "PlainFrame", "EndFrame", "BeginFrame", "BeginPlainFrame", "AgainFrame",
+                "Section", "Section*", "Subsection", "Subsection*", "Subsubsection", "Subsubsection*"]
     for lay in framebeg:
         i = 0
         while True:
@@ -3744,88 +4180,10 @@ def convert_lyxframes(document):
             parbeg = parent[3]
             if i != -1:
                 # Step I: Convert ERT arguments
-                # FIXME: This currently only works if the arguments are in one single ERT
-                ertend = i
-                if document.body[parbeg] == "\\begin_inset ERT":
-                    ertend = find_end_of_inset(document.body, parbeg)
-                    if ertend == -1:
-                        document.warning("Malformed LyX document: missing ERT \\end_inset")
-                        continue
-                    ertcont = parbeg + 5
-                    if document.body[ertcont].startswith("[<"):
-                        # This is a default overlay specification
-                        # strip off the [<
-                        document.body[ertcont] = document.body[ertcont][2:]
-                        if document.body[ertcont].endswith(">]"):
-                            # strip off the >]
-                            document.body[ertcont] = document.body[ertcont][:-2]
-                        elif document.body[ertcont].endswith("]"):
-                            # divide the args
-                            tok = document.body[ertcont].find('>][')
-                            if tok != -1:
-                                subst = [document.body[ertcont][:tok],
-                                         '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 3',
-                                         'status collapsed', '', '\\begin_layout Plain Layout',
-                                         document.body[ertcont][tok + 3:-1]]
-                                document.body[ertcont : ertcont + 1] = subst
-                                ertend += 11
-                        # Convert to ArgInset
-                        document.body[parbeg] = "\\begin_inset Argument 2"
-                    elif document.body[ertcont].startswith("<"):
-                        # This is an overlay specification
-                        # strip off the <
-                        document.body[ertcont] = document.body[ertcont][1:]
-                        if document.body[ertcont].endswith(">"):
-                            # strip off the >
-                            document.body[ertcont] = document.body[ertcont][:-1]
-                            # Convert to ArgInset
-                            document.body[parbeg] = "\\begin_inset Argument 1"
-                        elif document.body[ertcont].endswith(">]"):
-                            # divide the args
-                            tok = document.body[ertcont].find('>[<')
-                            if tok != -1:
-                               document.body[ertcont : ertcont + 1] = [document.body[ertcont][:tok],
-                                                               '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 2',
-                                                               'status collapsed', '', '\\begin_layout Plain Layout',
-                                                               document.body[ertcont][tok + 3:-2]]
-                            # Convert to ArgInset
-                            document.body[parbeg] = "\\begin_inset Argument 1"
-                            ertend += 11
-                        elif document.body[ertcont].endswith("]"):
-                            # divide the args
-                            tok = document.body[ertcont].find('>[<')
-                            if tok != -1:
-                               # divide the args
-                               tokk = document.body[ertcont].find('>][')
-                               if tokk != -1:
-                                   document.body[ertcont : ertcont + 1] = [document.body[ertcont][:tok],
-                                                                   '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 2',
-                                                                   'status collapsed', '', '\\begin_layout Plain Layout',
-                                                                   document.body[ertcont][tok + 3:tokk],
-                                                                   '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 3',
-                                                                   'status collapsed', '', '\\begin_layout Plain Layout',
-                                                                   document.body[ertcont][tokk + 3:-1]]
-                                   ertend += 22
-                            else:
-                                tokk = document.body[ertcont].find('>[')
-                                if tokk != -1:
-                                    document.body[ertcont : ertcont + 1] = [document.body[ertcont][:tokk],
-                                                                    '\\end_layout', '', '\\end_inset', '', '', '\\begin_inset Argument 3',
-                                                                    'status collapsed', '', '\\begin_layout Plain Layout',
-                                                                    document.body[ertcont][tokk + 2:-1]]
-                                    ertend += 11
-                            # Convert to ArgInset
-                            document.body[parbeg] = "\\begin_inset Argument 1"
-                    elif document.body[ertcont].startswith("["):
-                        # This is an ERT option
-                        # strip off the [
-                        document.body[ertcont] = document.body[ertcont][1:]
-                        if document.body[ertcont].endswith("]"):
-                            # strip off the ]
-                            document.body[ertcont] = document.body[ertcont][:-1]
-                            # Convert to ArgInset
-                            document.body[parbeg] = "\\begin_inset Argument 3"
-                # End of argument conversion
+                # FIXME: See restrictions in convert_beamerframeargs method
+                ertend = convert_beamerframeargs(document, i, parbeg)
+                if ertend == -1:
+                    break
                 # Step II: Now rename the layout and convert the title to an argument
                 j = find_end_of_layout(document.body, i)
                 document.body[j : j + 1] = ['\\end_layout', '', '\\end_inset', '', '\\end_layout']
@@ -3838,6 +4196,7 @@ def convert_lyxframes(document):
                 # Step III: find real frame end
                 j = j + 8
                 jj = j
+                inInset = get_containing_inset(document.body, i)
                 while True:
                     fend = find_token(document.body, "\\begin_layout", jj)
                     if fend == -1:
@@ -3847,9 +4206,20 @@ def convert_lyxframes(document):
                     if val not in frameend:
                         jj = fend + 1
                         continue
-                    old = document.body[fend]
+                    # is this frame nested in an inset (e.g., Note)?
+                    if inInset != False:
+                        # if so, end the frame inside the inset
+                        if inInset[2] < fend:
+                            fend = inInset[2]
                     if val == frametype:
                         document.body[fend : fend] = ['\\end_deeper', '', '\\begin_layout Separator', '', '\\end_layout']
+                    # consider explicit EndFrames between two identical frame types
+                    elif val == "EndFrame":
+                        nextlayout = find_token(document.body, "\\begin_layout", fend + 1)
+                        if nextlayout != -1 and get_value(document.body, "\\begin_layout", nextlayout) == frametype:
+                            document.body[fend : fend] = ['\\end_deeper', '', '\\begin_layout Separator', '', '\\end_layout']
+                        else:
+                            document.body[fend : fend] = ['\\end_deeper']
                     else:
                         document.body[fend : fend] = ['\\end_deeper']
                     document.body[j + 1 : j + 1] = ['', '\\begin_deeper']
@@ -3859,11 +4229,11 @@ def convert_lyxframes(document):
 
 def remove_endframes(document):
     " Remove deprecated beamer endframes "
-    
+
     beamer_classes = ["beamer", "article-beamer", "scrarticle-beamer"]
     if document.textclass not in beamer_classes:
         return
-   
+
     i = 0
     while True:
         i = find_token_exact(document.body, "\\begin_layout EndFrame", i)
@@ -3872,14 +4242,14 @@ def remove_endframes(document):
         j = find_end_of_layout(document.body, i)
         if j == -1:
             document.warning("Malformed LyX document: Missing \\end_layout to EndFrame")
-            i = i + 1
+            i += 1
             continue
         del document.body[i : j + 1]
 
 
 def revert_powerdot_flexes(document):
     " Reverts powerdot flex insets "
-    
+
     if document.textclass != "powerdot":
         return
 
@@ -3927,13 +4297,13 @@ def revert_powerdot_flexes(document):
                 z += len(pre)
                 document.body[i : beginPlain + 1] = pre
                 post = put_cmd_in_ert("}")
-                document.body[z - 2 : z + 1] = post     
+                document.body[z - 2 : z + 1] = post
         i += 1
 
 
 def revert_powerdot_pause(document):
     " Reverts powerdot pause layout to ERT "
-    
+
     if document.textclass != "powerdot":
         return
 
@@ -3945,7 +4315,7 @@ def revert_powerdot_pause(document):
         j = find_end_of_layout(document.body, i)
         if j == -1:
             document.warning("Malformed LyX document: Can't find end of Pause layout")
-            i = i + 1
+            i += 1
             continue
         endlay = j
         subst = ["\\begin_layout Standard"] + put_cmd_in_ert("\\pause")
@@ -3963,14 +4333,14 @@ def revert_powerdot_pause(document):
                 # Remove arg inset
                 del document.body[p : endInset + 1]
                 subst += put_cmd_in_ert("[") + content + put_cmd_in_ert("]")
-                    
+
         document.body[i : i + 1] = subst
         i = endlay
 
 
 def revert_powerdot_itemargs(document):
     " Reverts powerdot item arguments to ERT "
-    
+
     if document.textclass != "powerdot":
         return
 
@@ -3986,7 +4356,7 @@ def revert_powerdot_itemargs(document):
         parent = get_containing_layout(document.body, i)
         if parent == False:
             document.warning("Malformed LyX document: Can't find parent paragraph layout")
-            i = i + 1
+            i += 1
             continue
         parbeg = parent[1]
         parend = parent[2]
@@ -4019,7 +4389,7 @@ def revert_powerdot_itemargs(document):
                         del document.body[i:j+1]
                         subst = put_cmd_in_ert("<") + content + put_cmd_in_ert(">")
                         document.body[realparbeg : realparbeg] = subst
-        
+
         i = realparend
 
 
@@ -4037,7 +4407,7 @@ def revert_powerdot_columns(document):
         j = find_end_of_layout(document.body, i)
         if j == -1:
             document.warning("Malformed LyX document: Can't find end of Twocolumn layout")
-            i = i + 1
+            i += 1
             continue
         endlay = j
         document.body[j : j] = put_cmd_in_ert("}") + document.body[j : j]
@@ -4069,7 +4439,7 @@ def revert_powerdot_columns(document):
                     # Remove arg inset
                     del document.body[p : endInset + 1]
                     subst += put_cmd_in_ert("{") + content + put_cmd_in_ert("}")
-                    
+
         subst += put_cmd_in_ert("{")
         document.body[i : i + 1] = subst
         i = endlay
@@ -4093,7 +4463,7 @@ def revert_mbox_fbox(document):
             i += 1
             continue
         BeginLayout = find_token(document.body, "\\begin_layout Plain Layout", j)
-        EndLayout = find_token(document.body, "\\end_layout", BeginLayout)
+        EndLayout = find_end_of_layout(document.body, BeginLayout)
         # replace if width is ""
         if (width == '""'):
             document.body[EndLayout:k + 1] = put_cmd_in_ert("}")
@@ -4101,12 +4471,12 @@ def revert_mbox_fbox(document):
                 document.body[i:BeginLayout + 1] = put_cmd_in_ert("\\mbox{")
             if document.body[i] == "\\begin_inset Box Boxed":
                 document.body[i:BeginLayout + 1] = put_cmd_in_ert("\\fbox{")
-        i = i + 1
+        i += 1
 
 
 def revert_starred_caption(document):
     " Reverts unnumbered longtable caption insets "
-    
+
     i = 0
     while True:
       i = find_token(document.body, "\\begin_inset Caption LongTableNoNumber", i)
@@ -4115,7 +4485,7 @@ def revert_starred_caption(document):
       # This is not equivalent, but since the caption inset is a full blown
       # text inset a true conversion to ERT is too difficult.
       document.body[i] = "\\begin_inset Caption Standard"
-      i = i + 1
+      i += 1
 
 
 def revert_forced_local_layout(document):
@@ -4161,7 +4531,7 @@ def revert_aa1(document):
         i = find_token(document.body, "\\begin_layout Abstract (structured)", i)
       if i != -1:
         revert_Argument_to_TeX_brace(document, i, 0, 1, 4, False, False)
-        i = i + 1
+        i += 1
       if i == -1:
         return
 
@@ -4175,11 +4545,248 @@ def revert_aa2(document):
         i = find_token(document.body, "\\begin_layout Abstract (structured)", i)
       if i != -1:
         document.body[i] = "\\begin_layout Abstract"
-        i = i + 1
+        i += 1
       if i == -1:
         return
 
 
+def revert_tibetan(document):
+    "Set the document language for Tibetan to English"
+
+    revert_language(document, "tibetan", "", "tibetan")
+
+
+#############
+#
+# Chunk stuff
+#
+#############
+
+# The idea here is that we will have a sequence of chunk paragraphs.
+# We want to convert them to paragraphs in one or several chunk insets.
+# Individual chunks are terminated by the character @ on the last line.
+# This line will be discarded, and following lines are treated as new
+# chunks, which go into their own insets.
+# The first line of a chunk should look like: <<CONTENT>>=
+# We will discard the delimiters, and put the CONTENT into the
+# optional argument of the inset, if the CONTENT is non-empty.
+def convert_chunks(document):
+    first_re = re.compile(r'<<(.*)>>=(.*)')
+    file_pos = 0
+    while True:
+        # find start of a block of chunks
+        i = find_token(document.body, "\\begin_layout Chunk", file_pos)
+        if i == -1:
+            return
+        start = i
+        end = -1
+        contents = []
+        chunk_started = False
+
+        while True:
+            # process the one we just found
+            j = find_end_of_layout(document.body, i)
+            if j == -1:
+                document.warning("Malformed LyX documents. Can't find end of Chunk layout!")
+                # there is no point continuing, as we will run into the same error again.
+                return
+            this_chunk = "".join(document.body[i + 1:j])
+
+            # there may be empty lines between chunks
+            # we just skip them.
+            if not chunk_started:
+                if this_chunk != "":
+                    # new chunk starts
+                    chunk_started = True
+
+            if chunk_started:
+                contents.append(document.body[i + 1:j])
+
+            # look for potential chunk terminator
+            # on the last line of the chunk paragraph
+            if document.body[j - 1] == "@":
+                break
+
+            # look for subsequent chunk paragraph
+            i = find_token(document.body, "\\begin_layout", j)
+            if i == -1:
+                break
+
+            if get_value(document.body, "\\begin_layout", i) != "Chunk":
+                break
+
+        file_pos = end = j + 1
+
+        # The last chunk should simply have an "@" in it
+        # or at least end with "@" (can happen if @ is
+        # preceded by a newline)
+        lastpar = ''
+        if len(contents) > 0:
+            lastpar = ''.join(contents[-1])
+        if not lastpar.endswith("@"):
+            document.warning("Unexpected chunk content: chunk not terminated by '@'!")
+            if len(contents) == 0:
+                # convert empty chunk layouts to Standard
+                document.body[start] = "\\begin_layout Standard"
+            continue
+
+        if lastpar == "@":
+            # chunk par only contains "@". Just drop it.
+            contents.pop()
+        else:
+            # chunk par contains more. Only drop the "@".
+            contents[-1].pop()
+
+        # The first line should look like: <<CONTENT>>=
+        # We want the CONTENT
+        optarg = ' '.join(contents[0])
+        optarg.strip()
+        # We can already have real chunk content in
+        # the first par (separated from the options by a newline).
+        # We collect such stuff to re-insert it later.
+        postoptstuff = []
+
+        match = first_re.search(optarg)
+        if match:
+            optarg = match.groups()[0]
+            if match.groups()[1] != "":
+                postopt = False
+                for c in contents[0]:
+                    if c.endswith(">>="):
+                        postopt = True
+                        continue
+                    if postopt:
+                        postoptstuff.append(c)
+            # We have stripped everything. This can be deleted.
+            contents.pop(0)
+
+        newstuff = ['\\begin_layout Standard']
+
+        # Maintain paragraph parameters
+        par_params = ["\\noindent", "\\indent", "\\indent-toggle", "\\leftindent",
+                      "\\start_of_appendix", "\\paragraph_spacing", "\\align",
+                      "\\labelwidthstring"]
+        parms = start + 1
+        while True:
+            if document.body[parms].split(' ', 1)[0] not in par_params:
+                break
+            newstuff.extend([document.body[parms]])
+            parms += 1
+
+        newstuff.extend(
+            ['\\begin_inset Flex Chunk',
+             'status open', '',
+             '\\begin_layout Plain Layout', ''])
+
+        # If we have a non-empty optional argument, insert it.
+        if match and optarg != "":
+            newstuff.extend(
+                ['\\begin_inset Argument 1',
+                 'status open', '',
+                 '\\begin_layout Plain Layout',
+                 optarg,
+                 '\\end_layout', '',
+                 '\\end_inset', ''])
+
+        # Since we already opened a Plain layout, the first paragraph
+        # does not need to do that.
+        did_one_par = False
+        if postoptstuff:
+            # we need to replace newlines with new layouts
+            start_newline = -1
+            started_text = False
+            for lno in range(0,len(postoptstuff)):
+                if postoptstuff[lno].startswith("\\begin_inset Newline newline"):
+                    start_newline = lno
+                elif start_newline != -1:
+                    if postoptstuff[lno].startswith("\\end_inset"):
+                        # replace that bit, but only if we already have some text
+                        # and we're not at the end except for a blank line
+                        if started_text and \
+                          (lno != len(postoptstuff) - 2 or postoptstuff[-1] != ""):
+                            newstuff.extend(['\\end_layout', '\n', '\\begin_layout Plain Layout', '\n'])
+                        start_newline = -1
+                        started_text = True
+                else:
+                    newstuff.extend([postoptstuff[lno]])
+            newstuff.append('\\end_layout')
+            did_one_par = True
+        for c in contents:
+            if did_one_par:
+                newstuff.extend(['', '\\begin_layout Plain Layout', ''])
+            else:
+                did_one_par = True
+            newstuff.extend(c)
+            newstuff.append('\\end_layout')
+
+        newstuff.extend(['', '\\end_inset', '', '\\end_layout', ''])
+
+        document.body[start:end] = newstuff
+
+        file_pos += len(newstuff) - (end - start)
+
+
+def revert_chunks(document):
+    i = 0
+    while True:
+        i = find_token(document.body, "\\begin_inset Flex Chunk", i)
+        if i == -1:
+            return
+
+        iend = find_end_of_inset(document.body, i)
+        if iend == -1:
+            document.warning("Can't find end of Chunk!")
+            i += 1
+            continue
+
+        # Look for optional argument
+        optarg = ""
+        ostart = find_token(document.body, "\\begin_inset Argument 1", i, iend)
+        if ostart != -1:
+            oend = find_end_of_inset(document.body, ostart)
+            k = find_token(document.body, "\\begin_layout Plain Layout", ostart, oend)
+            if k == -1:
+                document.warning("Malformed LyX document: Can't find argument contents!")
+            else:
+                m = find_end_of_layout(document.body, k)
+                optarg = "".join(document.body[k+1:m])
+
+            # We now remove the optional argument, so we have something
+            # uniform on which to work
+            document.body[ostart : oend + 1] = []
+            # iend is now invalid
+            iend = find_end_of_inset(document.body, i)
+
+        retval = get_containing_layout(document.body, i)
+        if not retval:
+            document.warning("Can't find containing layout for Chunk!")
+            i = iend
+            continue
+        (lname, lstart, lend, pstart)  = retval
+        # we now want to work through the various paragraphs, and collect their contents
+        parlist = []
+        k = i
+        while True:
+            k = find_token(document.body, "\\begin_layout Plain Layout", k, lend)
+            if k == -1:
+                break
+            j = find_end_of_layout(document.body, k)
+            if j == -1:
+                document.warning("Can't find end of layout inside chunk!")
+                break
+            parlist.append(document.body[k+1:j])
+            k = j
+        # we now need to wrap all of these paragraphs in chunks
+        newlines = []
+        newlines.extend(["\\begin_layout Chunk", "", "<<" + optarg + ">>=", "\\end_layout", ""])
+        for stuff in parlist:
+            newlines.extend(["\\begin_layout Chunk"] + stuff + ["\\end_layout", ""])
+        newlines.extend(["\\begin_layout Chunk", "", "@", "\\end_layout", ""])
+        # replace old content with new content
+        document.body[lstart : lend + 1] = newlines
+        i = lstart + len(newlines)
+
+
 ##
 # Conversion hub
 #
@@ -4190,13 +4797,16 @@ convert = [
            [415, [convert_undertilde]],
            [416, []],
            [417, [convert_japanese_encodings]],
-           [418, []],
+           [418, [convert_justification]],
            [419, []],
            [420, [convert_biblio_style]],
            [421, [convert_longtable_captions]],
            [422, [convert_use_packages]],
            [423, [convert_use_mathtools]],
            [424, [convert_cite_engine_type]],
+           # No convert_cancel, since cancel will be loaded automatically
+           # in format 425 without any possibility to switch it off.
+           # This has been fixed in format 464.
            [425, []],
            [426, []],
            [427, []],
@@ -4212,7 +4822,7 @@ convert = [
            [437, []],
            [438, []],
            [439, []],
-           [440, []],
+           [440, [convert_mathfonts]],
            [441, [convert_mdnomath]],
            [442, []],
            [443, []],
@@ -4244,10 +4854,14 @@ convert = [
            [469, []],
            [470, []],
            [471, [convert_cite_engine_type_default]],
-           [472, []]
+           [472, []],
+           [473, []],
+           [474, [convert_chunks, cleanup_beamerargs]],
           ]
 
 revert =  [
+           [473, [revert_chunks]],
+           [472, [revert_tibetan]],
            [471, [revert_aa1,revert_aa2]],
            [470, [revert_cite_engine_type_default]],
            [469, [revert_forced_local_layout]],
@@ -4273,7 +4887,7 @@ revert =  [
            [449, [revert_garamondx, revert_garamondx_newtxmath]],
            [448, [revert_itemargs]],
            [447, [revert_literate]],
-           [446, [revert_IEEEtran, revert_IEEEtran_2, revert_AASTeX, revert_AGUTeX, revert_IJMP, revert_SIGPLAN, revert_SIGGRAPH, revert_EuropeCV, revert_Initials, revert_ModernCV_3]],
+           [446, [revert_IEEEtran, revert_IEEEtran_2, revert_AASTeX, revert_AGUTeX, revert_IJMP, revert_SIGPLAN, revert_SIGGRAPH, revert_EuropeCV, revert_Initials, revert_ModernCV_3, revert_ModernCV_4]],
            [445, [revert_latexargs]],
            [444, [revert_uop]],
            [443, [revert_biolinum]],