]> git.lyx.org Git - lyx.git/blobdiff - src/tex2lyx/Preamble.cpp
BufferParams: rename formula_indent to math_indent etc. as requested
[lyx.git] / src / tex2lyx / Preamble.cpp
index f48da7ab90e1df4d2b19bbaf76a384833f5d4a45..08d019c49e6bf30e3448c981314c3f1eee035c9e 100644 (file)
@@ -52,17 +52,17 @@ namespace {
  */
 const char * const known_languages[] = {"acadian", "afrikaans", "albanian",
 "american", "arabic", "arabtex", "australian", "austrian", "bahasa", "bahasai",
-"bahasam", "basque", "belarusian", "brazil", "brazilian", "breton", "british",
+"bahasam", "basque", "belarusian", "bosnian", "brazil", "brazilian", "breton", "british",
 "bulgarian", "canadian", "canadien", "catalan", "croatian", "czech", "danish",
 "dutch", "english", "esperanto", "estonian", "farsi", "finnish", "francais",
-"french", "frenchb", "frenchle", "frenchpro", "galician", "german", "germanb",
+"french", "frenchb", "frenchle", "frenchpro", "friulan", "galician", "german", "germanb",
 "georgian", "greek", "hebrew", "hungarian", "icelandic", "indon", "indonesian",
 "interlingua", "irish", "italian", "japanese", "kazakh", "kurmanji", "latin",
-"latvian", "lithuanian", "lowersorbian", "lsorbian", "magyar", "malay", "meyalu",
+"latvian", "lithuanian", "lowersorbian", "lsorbian", "macedonian", "magyar", "malay", "meyalu",
 "mongolian", "naustrian", "newzealand", "ngerman", "ngermanb", "norsk", "nswissgerman",
-"nynorsk", "polutonikogreek", "polish", "portuges", "portuguese", "romanian", "russian",
-"russianb", "samin", "scottish", "serbian", "serbian-latin", "slovak",
-"slovene", "spanish", "swedish", "swissgerman", "thai", "turkish", "turkmen",
+"nynorsk", "piedmontese", "polutonikogreek", "polish", "portuges", "portuguese",
+"romanian", "romansh", "russian", "russianb", "samin", "scottish", "serbian", "serbian-latin",
+"slovak", "slovene", "spanish", "swedish", "swissgerman", "thai", "turkish", "turkmen",
 "ukraineb", "ukrainian", "uppersorbian", "UKenglish", "USenglish", "usorbian",
 "vietnam", "welsh",
 0};
@@ -73,17 +73,17 @@ const char * const known_languages[] = {"acadian", "afrikaans", "albanian",
  */
 const char * const known_coded_languages[] = {"french", "afrikaans", "albanian",
 "american", "arabic_arabi", "arabic_arabtex", "australian", "austrian", "bahasa", "bahasa",
-"bahasam", "basque", "belarusian", "brazilian", "brazilian", "breton", "british",
+"bahasam", "basque", "belarusian", "bosnian", "brazilian", "brazilian", "breton", "british",
 "bulgarian", "canadian", "canadien", "catalan", "croatian", "czech", "danish",
 "dutch", "english", "esperanto", "estonian", "farsi", "finnish", "french",
-"french", "french", "french", "french", "galician", "german", "german",
+"french", "french", "french", "french", "friulan", "galician", "german", "german",
 "georgian", "greek", "hebrew", "magyar", "icelandic", "bahasa", "bahasa",
 "interlingua", "irish", "italian", "japanese", "kazakh", "kurmanji", "latin",
-"latvian", "lithuanian", "lowersorbian", "lowersorbian", "magyar", "bahasam", "bahasam",
+"latvian", "lithuanian", "lowersorbian", "lowersorbian", "macedonian", "magyar", "bahasam", "bahasam",
 "mongolian", "naustrian", "newzealand", "ngerman", "ngerman", "norsk", "german-ch",
-"nynorsk", "polutonikogreek", "polish", "portuguese", "portuguese", "romanian", "russian",
-"russian", "samin", "scottish", "serbian", "serbian-latin", "slovak",
-"slovene", "spanish", "swedish", "german-ch-old", "thai", "turkish", "turkmen",
+"nynorsk", "piedmontese", "polutonikogreek", "polish", "portuguese", "portuguese",
+"romanian", "romansh", "russian", "russian", "samin", "scottish", "serbian", "serbian-latin",
+"slovak", "slovene", "spanish", "swedish", "german-ch-old", "thai", "turkish", "turkmen",
 "ukrainian", "ukrainian", "uppersorbian", "english", "english", "uppersorbian",
 "vietnamese", "welsh",
 0};
@@ -99,18 +99,19 @@ const char * const known_english_quotes_languages[] = {"american", "australian",
 
 /// languages with french quotes (.lyx names)
 const char * const known_french_quotes_languages[] = {"albanian",
-"arabic_arabi", "arabic_arabtex", "basque", "canadien", "catalan", "french",
-"galician", "greek", "italian", "norsk", "nynorsk", "polutonikogreek",
-"russian", "spanish", "spanish-mexico", "turkish", "turkmen", "ukrainian",
-"vietnamese", 0};
+"arabic_arabi", "arabic_arabtex", "asturian", "basque", "canadien", "catalan",
+"french", "friulan", "galician", "greek", "italian", "norsk", "nynorsk",
+"piedmontese", "polutonikogreek", "russian", "spanish", "spanish-mexico",
+"turkish", "turkmen", "ukrainian", "vietnamese", 0};
 
 /// languages with german quotes (.lyx names)
 const char * const known_german_quotes_languages[] = {"austrian", "bulgarian",
-"czech", "german", "georgian", "icelandic", "lithuanian", "lowersorbian", "naustrian",
-"ngerman", "serbian", "serbian-latin", "slovak", "slovene", "uppersorbian", 0};
+"czech", "german", "georgian", "icelandic", "lithuanian", "lowersorbian", "macedonian",
+"naustrian", "ngerman", "romansh", "serbian", "serbian-latin", "slovak", "slovene",
+"uppersorbian", 0};
 
 /// languages with polish quotes (.lyx names)
-const char * const known_polish_quotes_languages[] = {"afrikaans", "croatian",
+const char * const known_polish_quotes_languages[] = {"afrikaans", "bosnian", "croatian",
 "dutch", "estonian", "magyar", "polish", "romanian", 0};
 
 /// languages with swedish quotes (.lyx names)
@@ -124,17 +125,18 @@ const char * const known_old_language_packages[] = {"french", "frenchle",
 char const * const known_fontsizes[] = { "10pt", "11pt", "12pt", 0 };
 
 const char * const known_roman_fonts[] = { "ae", "beraserif", "bookman",
-"ccfonts", "chancery", "charter", "cmr", "fourier", "garamondx", "libertine",
-"libertine-type1", "lmodern", "mathdesign", "mathpazo", "mathptmx", "newcent",
-"tgbonum", "tgchorus", "tgpagella", "tgschola", "tgtermes", "utopia", 0};
+"ccfonts", "chancery", "charter", "cmr", "cochineal", "crimson", "fourier",
+"garamondx", "libertine", "libertine-type1", "lmodern", "mathdesign", "mathpazo",
+"mathptmx", "newcent", "NotoSerif-TLF", "tgbonum", "tgchorus", "tgpagella", "tgschola",
+"tgtermes", "utopia", 0};
 
 const char * const known_sans_fonts[] = { "avant", "berasans", "biolinum-type1",
 "cmbr", "cmss", "helvet", "iwona", "iwonac", "iwonal", "iwonalc", "kurier",
-"kurierc", "kurierl", "kurierlc", "lmss", "tgadventor", "tgheros", 0};
+"kurierc", "kurierl", "kurierlc", "lmss", "NotoSans-TLF", "tgadventor", "tgheros", 0};
 
 const char * const known_typewriter_fonts[] = { "beramono", "cmtl", "cmtt",
 "courier", "lmtt", "luximono", "fourier", "libertineMono-type1", "lmodern",
-"mathpazo", "mathptmx", "newcent", "tgcursor", "txtt", 0};
+"mathpazo", "mathptmx", "newcent", "NotoMono-TLF", "tgcursor", "txtt", 0};
 
 const char * const known_math_fonts[] = { "eulervm", "newtxmath", 0};
 
@@ -185,9 +187,6 @@ const char * const known_lyx_packages[] = {"amsbsy", "amsmath", "amssymb",
 "rotfloat", "splitidx", "setspace", "subscript", "textcomp", "tipa", "tipx",
 "tone", "ulem", "url", "varioref", "verbatim", "wrapfig", "xcolor", "xunicode", 0};
 
-// used for the handling of \newindex
-int index_number = 0;
-
 // codes used to remove packages that are loaded automatically by LyX.
 // Syntax: package_beg_sep<name>package_mid_sep<package loading code>package_end_sep
 const char package_beg_sep = '\001';
@@ -299,36 +298,38 @@ string process_keyval_opt(vector<string> & options, string name)
  * FIXME: support spelling=old for german variants (german vs. ngerman LyX names etc)
  */
 const char * const Preamble::polyglossia_languages[] = {
-"albanian", "croatian", "hebrew", "norsk", "swedish", "amharic", "czech", "hindi",
-"nynorsk", "syriac", "arabic", "danish", "icelandic", "occitan", "tamil",
-"armenian", "divehi", "interlingua", "polish", "telugu", "asturian", "dutch",
-"irish", "portuges", "thai", "bahasai", "english", "italian", "romanian", "turkish",
-"bahasam", "esperanto", "lao", "russian", "turkmen", "basque", "estonian", "latin",
-"samin", "ukrainian", "bengali", "farsi", "latvian", "sanskrit", "tibetan", "urdu",
-"brazil", "brazilian", "finnish", "lithuanian", "scottish", "usorbian", "breton",
-"french", "lsorbian", "serbian", "vietnamese", "bulgarian", "galician", "magyar",
-"slovak", "welsh", "catalan", "german", "malayalam", "slovenian", "coptic", "greek",
-"marathi", "spanish", "austrian",
-"american", "ancient", "australian", "british", "monotonic", "newzealand",
-"polytonic", 0};
+"albanian", "american", "amharic", "ancient", "arabic", "armenian", "asturian", "australian",
+"bahasai", "bahasam", "basque", "bengali", "brazil", "brazilian", "breton", "british", "bulgarian",
+"catalan", "coptic", "croatian", "czech", "danish", "divehi", "dutch",
+"english", "esperanto", "estonian", "farsi", "finnish", "french", "friulan",
+"galician", "greek", "monotonic", "hebrew", "hindi",
+"icelandic", "interlingua", "irish", "italian", "kannada", "khmer",
+"lao", "latin", "latvian", "lithuanian", "lsorbian", "magyar", "malayalam", "marathi",
+"austrian", "newzealand", "german", "norsk", "nynorsk", "occitan",
+"piedmontese", "polish", "polytonic", "portuges", "romanian", "romansh", "russian",
+"samin", "sanskrit", "scottish", "serbian", "slovak", "slovenian", "spanish", "swedish", "syriac",
+"tamil", "telugu", "thai", "tibetan", "turkish", "turkmen",
+"ukrainian", "urdu", "usorbian", "vietnamese", "welsh", 0};
+// not yet supported by LyX: "korean", "nko"
 
 /**
  * the same as polyglossia_languages with .lyx names
  * please keep this in sync with polyglossia_languages line by line!
  */
 const char * const Preamble::coded_polyglossia_languages[] = {
-"albanian", "croatian", "hebrew", "norsk", "swedish", "amharic", "czech", "hindi",
-"nynorsk", "syriac", "arabic_arabi", "danish", "icelandic", "occitan", "tamil",
-"armenian", "divehi", "interlingua", "polish", "telugu", "asturian", "dutch",
-"irish", "portuges", "thai", "bahasa", "english", "italian", "romanian", "turkish",
-"bahasam", "esperanto", "lao", "russian", "turkmen", "basque", "estonian", "latin",
-"samin", "ukrainian", "bengali", "farsi", "latvian", "sanskrit", "tibetan", "urdu",
-"brazilian", "brazilian", "finnish", "lithuanian", "scottish", "uppersorbian", "breton",
-"french", "lowersorbian", "serbian", "vietnamese", "bulgarian", "galician", "magyar",
-"slovak", "welsh", "catalan", "ngerman", "malayalam", "slovene", "coptic", "greek",
-"marathi", "spanish", "naustrian",
-"american", "ancientgreek", "australian", "british", "greek", "newzealand",
-"polutonikogreek", 0};
+"albanian", "american", "amharic", "ancientgreek", "arabic_arabi", "armenian", "asturian", "australian",
+"bahasa", "bahasam", "basque", "bengali", "brazilian", "brazilian", "breton", "british", "bulgarian",
+"catalan", "coptic", "croatian", "czech", "danish", "divehi", "dutch",
+"english", "esperanto", "estonian", "farsi", "finnish", "french", "friulan",
+"galician", "greek", "greek", "hebrew", "hindi",
+"icelandic", "interlingua", "irish", "italian", "kannada", "khmer",
+"lao", "latin", "latvian", "lithuanian", "lowersorbian", "magyar", "malayalam", "marathi",
+"naustrian","newzealand", "ngerman", "norsk", "nynorsk", "occitan",
+"piedmontese", "polish", "polutonikogreek", "portuges", "romanian", "romansh", "russian",
+"samin", "sanskrit", "scottish", "serbian", "slovak", "slovene", "spanish", "swedish", "syriac",
+"tamil", "telugu", "thai", "tibetan", "turkish", "turkmen",
+"ukrainian", "urdu", "uppersorbian", "vietnamese", "welsh", 0};
+// not yet supported by LyX: "korean-polyglossia", "nko"
 
 
 bool Preamble::usePolyglossia() const
@@ -460,7 +461,8 @@ string remove_braces(string const & value)
 
 
 Preamble::Preamble() : one_language(true), explicit_babel(false),
-       title_layout_found(false), h_font_cjk_set(false)
+       title_layout_found(false), index_number(0), h_font_cjk_set(false),
+       h_use_microtype("false")
 {
        //h_backgroundcolor;
        //h_boxbgcolor;
@@ -470,20 +472,28 @@ Preamble::Preamble() : one_language(true), explicit_babel(false),
        h_cite_engine_type        = "default";
        h_color                   = "#008000";
        h_defskip                 = "medskip";
+       h_dynamic_quotes          = false;
        //h_float_placement;
        //h_fontcolor;
        h_fontencoding            = "default";
-       h_font_roman              = "default";
-       h_font_sans               = "default";
-       h_font_typewriter         = "default";
-       h_font_math               = "auto";
+       h_font_roman[0]           = "default";
+       h_font_roman[1]           = "default";
+       h_font_sans[0]            = "default";
+       h_font_sans[1]            = "default";
+       h_font_typewriter[0]      = "default";
+       h_font_typewriter[1]      = "default";
+       h_font_math[0]            = "auto";
+       h_font_math[1]            = "auto";
        h_font_default_family     = "default";
        h_use_non_tex_fonts       = false;
        h_font_sc                 = "false";
        h_font_osf                = "false";
-       h_font_sf_scale           = "100";
-       h_font_tt_scale           = "100";
+       h_font_sf_scale[0]        = "100";
+       h_font_sf_scale[1]        = "100";
+       h_font_tt_scale[0]        = "100";
+       h_font_tt_scale[1]        = "100";
        //h_font_cjk
+       h_is_mathindent           = "0";
        h_graphics                = "default";
        h_default_output_format   = "default";
        h_html_be_strict          = "false";
@@ -526,19 +536,22 @@ Preamble::Preamble() : one_language(true), explicit_babel(false),
        h_pdf_pdfusetitle         = "0";
        //h_pdf_pagemode;
        //h_pdf_quoted_options;
-       h_quotes_language         = "english";
+       h_quotes_style         = "english";
        h_secnumdepth             = "3";
        h_shortcut[0]             = "idx";
        h_spacing                 = "single";
+       h_save_transient_properties = "true";
        h_suppress_date           = "false";
        h_textclass               = "article";
        h_tocdepth                = "3";
        h_tracking_changes        = "false";
        h_use_bibtopic            = "false";
+       h_use_dash_ligatures      = "true";
        h_use_indices             = "false";
        h_use_geometry            = "false";
        h_use_default_options     = "false";
        h_use_hyperref            = "false";
+       h_use_microtype           = "false";
        h_use_refstyle            = false;
        h_use_packages["amsmath"]    = "1";
        h_use_packages["amssymb"]    = "0";
@@ -668,7 +681,8 @@ void Preamble::handle_geometry(vector<string> & options)
 
 
 void Preamble::handle_package(Parser &p, string const & name,
-                              string const & opts, bool in_lyx_preamble)
+                              string const & opts, bool in_lyx_preamble,
+                              bool detectEncoding)
 {
        vector<string> options = split_options(opts);
        add_package(name, options);
@@ -684,25 +698,25 @@ void Preamble::handle_package(Parser &p, string const & name,
 
        // roman fonts
        if (is_known(name, known_roman_fonts))
-               h_font_roman = name;
+               h_font_roman[0] = name;
 
        if (name == "fourier") {
-               h_font_roman = "utopia";
+               h_font_roman[0] = "utopia";
                // when font uses real small capitals
                if (opts == "expert")
                        h_font_sc = "true";
        }
 
        if (name == "garamondx") {
-               h_font_roman = "garamondx";
+               h_font_roman[0] = "garamondx";
                if (opts == "osfI")
                        h_font_osf = "true";
        }
 
        if (name == "libertine") {
-               h_font_roman = "libertine";
+               h_font_roman[0] = "libertine";
                // this automatically invokes biolinum
-               h_font_sans = "biolinum";
+               h_font_sans[0] = "biolinum";
                if (opts == "osf")
                        h_font_osf = "true";
                else if (opts == "lining")
@@ -710,7 +724,7 @@ void Preamble::handle_package(Parser &p, string const & name,
        }
 
        if (name == "libertine-type1") {
-               h_font_roman = "libertine";
+               h_font_roman[0] = "libertine";
                // NOTE: contrary to libertine.sty, libertine-type1
                // does not automatically invoke biolinum
                if (opts == "lining")
@@ -721,11 +735,11 @@ void Preamble::handle_package(Parser &p, string const & name,
 
        if (name == "mathdesign") {
                if (opts.find("charter") != string::npos)
-                       h_font_roman = "md-charter";
+                       h_font_roman[0] = "md-charter";
                if (opts.find("garamond") != string::npos)
-                       h_font_roman = "md-garamond";
+                       h_font_roman[0] = "md-garamond";
                if (opts.find("utopia") != string::npos)
-                       h_font_roman = "md-utopia";
+                       h_font_roman[0] = "md-utopia";
                if (opts.find("expert") != string::npos) {
                        h_font_sc = "true";
                        h_font_osf = "true";
@@ -733,22 +747,52 @@ void Preamble::handle_package(Parser &p, string const & name,
        }
 
        else if (name == "mathpazo")
-               h_font_roman = "palatino";
+               h_font_roman[0] = "palatino";
 
        else if (name == "mathptmx")
-               h_font_roman = "times";
+               h_font_roman[0] = "times";
+
+       if (name == "crimson")
+               h_font_roman[0] = "cochineal";
+
+       if (name == "cochineal") {
+               h_font_roman[0] = "cochineal";
+               // cochineal can have several options, e.g. [proportional,osf]
+               string::size_type pos = opts.find("osf");
+               if (pos != string::npos)
+                       h_font_osf = "true";
+       }
+
+       if (name == "noto") {
+               // noto can have several options
+               if (opts.empty())
+                       h_font_roman[0] = "NotoSerif-TLF";
+               string::size_type pos = opts.find("rm");
+               if (pos != string::npos)
+                       h_font_roman[0] = "NotoSerif-TLF";
+               pos = opts.find("sf");
+               if (pos != string::npos)
+                       h_font_sans[0] = "NotoSans-TLF";
+               pos = opts.find("nott");
+               if (pos != string::npos) {
+                       h_font_roman[0] = "NotoSerif-TLF";
+                       h_font_sans[0] = "NotoSans-TLF";
+               }
+               // noto as typewriter is handled in handling of \ttdefault
+               // special cases are handled in handling of \rmdefault and \sfdefault
+       }
 
        // sansserif fonts
        if (is_known(name, known_sans_fonts)) {
-               h_font_sans = name;
+               h_font_sans[0] = name;
                if (options.size() >= 1) {
-                       if (scale_as_percentage(opts, h_font_sf_scale))
+                       if (scale_as_percentage(opts, h_font_sf_scale[0]))
                                options.clear();
                }
        }
 
        if (name == "biolinum-type1") {
-               h_font_sans = "biolinum";
+               h_font_sans[0] = "biolinum";
                // biolinum can have several options, e.g. [osf,scaled=0.97]
                string::size_type pos = opts.find("osf");
                if (pos != string::npos)
@@ -760,16 +804,16 @@ void Preamble::handle_package(Parser &p, string const & name,
                // fourier can be set as roman font _only_
                // fourier as typewriter is handled in handling of \ttdefault
                if (name != "fourier") {
-                       h_font_typewriter = name;
+                       h_font_typewriter[0] = name;
                        if (options.size() >= 1) {
-                               if (scale_as_percentage(opts, h_font_tt_scale))
+                               if (scale_as_percentage(opts, h_font_tt_scale[0]))
                                        options.clear();
                        }
                }
        }
 
        if (name == "libertineMono-type1") {
-               h_font_typewriter = "libertine-mono";
+               h_font_typewriter[0] = "libertine-mono";
        }
 
        // font uses old-style figure
@@ -778,33 +822,35 @@ void Preamble::handle_package(Parser &p, string const & name,
 
        // math fonts
        if (is_known(name, known_math_fonts))
-               h_font_math = name;
+               h_font_math[0] = name;
 
        if (name == "newtxmath") {
                if (opts.empty())
-                       h_font_math = "newtxmath";
+                       h_font_math[0] = "newtxmath";
                else if (opts == "garamondx")
-                       h_font_math = "garamondx-ntxm";
+                       h_font_math[0] = "garamondx-ntxm";
                else if (opts == "libertine")
-                       h_font_math = "libertine-ntxm";
+                       h_font_math[0] = "libertine-ntxm";
                else if (opts == "minion")
-                       h_font_math = "minion-ntxm";
+                       h_font_math[0] = "minion-ntxm";
+               else if (opts == "cochineal")
+                       h_font_math[0] = "cochineal-ntxm";
        }
 
        if (name == "iwona")
                if (opts == "math")
-                       h_font_math = "iwona-math";
+                       h_font_math[0] = "iwona-math";
 
        if (name == "kurier")
                if (opts == "math")
-                       h_font_math = "kurier-math";
+                       h_font_math[0] = "kurier-math";
 
        // after the detection and handling of special cases, we can remove the
        // fonts, otherwise they would appear in the preamble, see bug #7856
        if (is_known(name, known_roman_fonts) || is_known(name, known_sans_fonts)
                ||      is_known(name, known_typewriter_fonts) || is_known(name, known_math_fonts))
                ;
-
+       //"On". See the enum Package in BufferParams.h if you thought that "2" should have been "42"
        else if (name == "amsmath" || name == "amssymb" || name == "cancel" ||
                 name == "esint" || name == "mhchem" || name == "mathdots" ||
                 name == "mathtools" || name == "stackrel" ||
@@ -905,9 +951,11 @@ void Preamble::handle_package(Parser &p, string const & name,
                        string const encoding = options.back();
                        Encoding const * const enc = encodings.fromLaTeXName(
                                encoding, Encoding::inputenc, true);
-                       if (!enc)
-                               cerr << "Unknown encoding " << encoding << ". Ignoring." << std::endl;
-                       else {
+                       if (!enc) {
+                               if (!detectEncoding)
+                                       cerr << "Unknown encoding " << encoding
+                                            << ". Ignoring." << std::endl;
+                       } else {
                                if (!enc->unsafe() && options.size() == 1 && one_language == true)
                                        h_inputencoding = enc->name();
                                p.setEncoding(enc->iconvName());
@@ -1006,6 +1054,13 @@ void Preamble::handle_package(Parser &p, string const & name,
                                h_options += ',' + join(options, ",");
                }
        }
+       else if (name == "microtype") {
+               //we internally support only microtype without params
+               if (options.empty())
+                       h_use_microtype = "true";
+               else
+                       h_preamble << "\\usepackage[" << opts << "]{microtype}";
+       }
 
        else if (!in_lyx_preamble) {
                if (options.empty())
@@ -1022,7 +1077,7 @@ void Preamble::handle_package(Parser &p, string const & name,
        }
 
        // We need to do something with the options...
-       if (!options.empty())
+       if (!options.empty() && !detectEncoding)
                cerr << "Ignoring options '" << join(options, ",")
                     << "' of package " << name << '.' << endl;
 
@@ -1060,22 +1115,22 @@ bool Preamble::writeLyXHeader(ostream & os, bool subdoc, string const & outfiled
        // (quotes for kazakh and interlingua are unknown)
        // danish
        if (is_known(h_language, known_danish_quotes_languages))
-               h_quotes_language = "danish";
+               h_quotes_style = "danish";
        // french
        else if (is_known(h_language, known_french_quotes_languages))
-               h_quotes_language = "french";
+               h_quotes_style = "french";
        // german
        else if (is_known(h_language, known_german_quotes_languages))
-               h_quotes_language = "german";
+               h_quotes_style = "german";
        // polish
        else if (is_known(h_language, known_polish_quotes_languages))
-               h_quotes_language = "polish";
+               h_quotes_style = "polish";
        // swedish
        else if (is_known(h_language, known_swedish_quotes_languages))
-               h_quotes_language = "swedish";
+               h_quotes_style = "swedish";
        //english
        else if (is_known(h_language, known_english_quotes_languages))
-               h_quotes_language = "english";
+               h_quotes_style = "english";
 
        if (contains(h_float_placement, "H"))
                registerAutomaticallyLoadedPackage("float");
@@ -1096,6 +1151,7 @@ bool Preamble::writeLyXHeader(ostream & os, bool subdoc, string const & outfiled
           << "\\lyxformat " << LYX_FORMAT << '\n'
           << "\\begin_document\n"
           << "\\begin_header\n"
+          << "\\save_transient_properties " << h_save_transient_properties << "\n"
           << "\\origin " << origin << "\n"
           << "\\textclass " << h_textclass << "\n";
        string const raw = subdoc ? empty_string() : h_preamble.str();
@@ -1138,19 +1194,25 @@ bool Preamble::writeLyXHeader(ostream & os, bool subdoc, string const & outfiled
           << "\\language_package " << h_language_package << "\n"
           << "\\inputencoding " << h_inputencoding << "\n"
           << "\\fontencoding " << h_fontencoding << "\n"
-          << "\\font_roman " << h_font_roman << "\n"
-          << "\\font_sans " << h_font_sans << "\n"
-          << "\\font_typewriter " << h_font_typewriter << "\n"
-          << "\\font_math " << h_font_math << "\n"
+          << "\\font_roman \"" << h_font_roman[0]
+          << "\" \"" << h_font_roman[1] << "\"\n"
+          << "\\font_sans \"" << h_font_sans[0] << "\" \"" << h_font_sans[1] << "\"\n"
+          << "\\font_typewriter \"" << h_font_typewriter[0]
+          << "\" \"" << h_font_typewriter[1] << "\"\n"
+          << "\\font_math \"" << h_font_math[0] << "\" \"" << h_font_math[1] << "\"\n"
           << "\\font_default_family " << h_font_default_family << "\n"
           << "\\use_non_tex_fonts " << (h_use_non_tex_fonts ? "true" : "false") << '\n'
           << "\\font_sc " << h_font_sc << "\n"
           << "\\font_osf " << h_font_osf << "\n"
-          << "\\font_sf_scale " << h_font_sf_scale << "\n"
-          << "\\font_tt_scale " << h_font_tt_scale << '\n';
+          << "\\font_sf_scale " << h_font_sf_scale[0]
+          << ' ' << h_font_sf_scale[1] << '\n'
+          << "\\font_tt_scale " << h_font_tt_scale[0]
+          << ' ' << h_font_tt_scale[1] << '\n';
        if (!h_font_cjk.empty())
                os << "\\font_cjk " << h_font_cjk << '\n';
-       os << "\\graphics " << h_graphics << '\n'
+       os << "\\use_microtype " << h_use_microtype << '\n'
+          << "\\use_dash_ligatures " << h_use_dash_ligatures << '\n'
+          << "\\graphics " << h_graphics << '\n'
           << "\\default_output_format " << h_default_output_format << "\n"
           << "\\output_sync " << h_output_sync << "\n";
        if (h_output_sync == "1")
@@ -1164,13 +1226,13 @@ bool Preamble::writeLyXHeader(ostream & os, bool subdoc, string const & outfiled
           << "\\use_hyperref " << h_use_hyperref << '\n';
        if (h_use_hyperref == "true") {
                if (!h_pdf_title.empty())
-                       os << "\\pdf_title \"" << h_pdf_title << "\"\n";
+                       os << "\\pdf_title " << Lexer::quoteString(h_pdf_title) << '\n';
                if (!h_pdf_author.empty())
-                       os << "\\pdf_author \"" << h_pdf_author << "\"\n";
+                       os << "\\pdf_author " << Lexer::quoteString(h_pdf_author) << '\n';
                if (!h_pdf_subject.empty())
-                       os << "\\pdf_subject \"" << h_pdf_subject << "\"\n";
+                       os << "\\pdf_subject " << Lexer::quoteString(h_pdf_subject) << '\n';
                if (!h_pdf_keywords.empty())
-                       os << "\\pdf_keywords \"" << h_pdf_keywords << "\"\n";
+                       os << "\\pdf_keywords " << Lexer::quoteString(h_pdf_keywords) << '\n';
                os << "\\pdf_bookmarks " << h_pdf_bookmarks << "\n"
                      "\\pdf_bookmarksnumbered " << h_pdf_bookmarksnumbered << "\n"
                      "\\pdf_bookmarksopen " << h_pdf_bookmarksopen << "\n"
@@ -1183,7 +1245,7 @@ bool Preamble::writeLyXHeader(ostream & os, bool subdoc, string const & outfiled
                if (!h_pdf_pagemode.empty())
                        os << "\\pdf_pagemode " << h_pdf_pagemode << '\n';
                if (!h_pdf_quoted_options.empty())
-                       os << "\\pdf_quoted_options \"" << h_pdf_quoted_options << "\"\n";
+                       os << "\\pdf_quoted_options " << Lexer::quoteString(h_pdf_quoted_options) << '\n';
        }
        os << "\\papersize " << h_papersize << "\n"
           << "\\use_geometry " << h_use_geometry << '\n';
@@ -1228,7 +1290,11 @@ bool Preamble::writeLyXHeader(ostream & os, bool subdoc, string const & outfiled
                os << "\\defskip " << h_defskip << "\n";
        else
                os << "\\paragraph_indentation " << h_paragraph_indentation << "\n";
-       os << "\\quotes_language " << h_quotes_language << "\n"
+       os << "\\is_math_indent " << h_is_mathindent << "\n";
+       if (!h_mathindentation.empty())
+               os << "\\math_indentation " << h_mathindentation << "\n";
+       os << "\\quotes_style " << h_quotes_style << "\n"
+          << "\\dynamic_quotes " << h_dynamic_quotes << "\n"
           << "\\papercolumns " << h_papercolumns << "\n"
           << "\\papersides " << h_papersides << "\n"
           << "\\paperpagestyle " << h_paperpagestyle << "\n";
@@ -1251,6 +1317,13 @@ void Preamble::parse(Parser & p, string const & forceclass,
 {
        // initialize fixed types
        special_columns_['D'] = 3;
+       parse(p, forceclass, false, tc);
+}
+
+
+void Preamble::parse(Parser & p, string const & forceclass,
+                     bool detectEncoding, TeX2LyXDocClass & tc)
+{
        bool is_full_document = false;
        bool is_lyx_file = false;
        bool in_lyx_preamble = false;
@@ -1266,11 +1339,19 @@ void Preamble::parse(Parser & p, string const & forceclass,
        }
        p.reset();
 
+       if (detectEncoding && !is_full_document)
+               return;
+
        while (is_full_document && p.good()) {
+               if (detectEncoding && h_inputencoding != "auto" &&
+                   h_inputencoding != "default")
+                       return;
+
                Token const & t = p.get_token();
 
 #ifdef FILEDEBUG
-               cerr << "t: " << t << "\n";
+               if (!detectEncoding)
+                       cerr << "t: " << t << '\n';
 #endif
 
                //
@@ -1305,7 +1386,8 @@ void Preamble::parse(Parser & p, string const & forceclass,
                        if (comment.size() > magicXeLaTeX.size()
                                  && comment.substr(0, magicXeLaTeX.size()) == magicXeLaTeX
                                  && h_inputencoding == "auto") {
-                               cerr << "XeLaTeX comment found, switching to UTF8\n";
+                               if (!detectEncoding)
+                                       cerr << "XeLaTeX comment found, switching to UTF8\n";
                                h_inputencoding = "utf8";
                        }
                        smatch sub;
@@ -1357,7 +1439,7 @@ void Preamble::parse(Parser & p, string const & forceclass,
                else if (t.cs() == "setmainfont") {
                        // we don't care about the option
                        p.hasOpt() ? p.getOpt() : string();
-                       h_font_roman = p.getArg('{', '}');
+                       h_font_roman[1] = p.getArg('{', '}');
                }
 
                else if (t.cs() == "setsansfont" || t.cs() == "setmonofont") {
@@ -1377,12 +1459,12 @@ void Preamble::parse(Parser & p, string const & forceclass,
                        }
                        if (t.cs() == "setsansfont") {
                                if (!scale.empty())
-                                       h_font_sf_scale = scale;
-                               h_font_sans = p.getArg('{', '}');
+                                       h_font_sf_scale[1] = scale;
+                               h_font_sans[1] = p.getArg('{', '}');
                        } else {
                                if (!scale.empty())
-                                       h_font_tt_scale = scale;
-                               h_font_typewriter = p.getArg('{', '}');
+                                       h_font_tt_scale[1] = scale;
+                               h_font_typewriter[1] = p.getArg('{', '}');
                        }
                }
 
@@ -1401,9 +1483,9 @@ void Preamble::parse(Parser & p, string const & forceclass,
                        // check the case that a standard color is used
                        if (space.empty() && is_known(argument, known_basic_colors)) {
                                h_fontcolor = rgbcolor2code(argument);
-                               preamble.registerAutomaticallyLoadedPackage("color");
+                               registerAutomaticallyLoadedPackage("color");
                        } else if (space.empty() && argument == "document_fontcolor")
-                               preamble.registerAutomaticallyLoadedPackage("color");
+                               registerAutomaticallyLoadedPackage("color");
                        // check the case that LyX's document_fontcolor is defined
                        // but not used for \color
                        else {
@@ -1423,7 +1505,7 @@ void Preamble::parse(Parser & p, string const & forceclass,
                        if (is_known(argument, known_basic_colors)) {
                                h_backgroundcolor = rgbcolor2code(argument);
                        } else if (argument == "page_backgroundcolor")
-                               preamble.registerAutomaticallyLoadedPackage("color");
+                               registerAutomaticallyLoadedPackage("color");
                        // check the case that LyX's page_backgroundcolor is defined
                        // but not used for \pagecolor
                        else {
@@ -1528,19 +1610,19 @@ void Preamble::parse(Parser & p, string const & forceclass,
                        // font settings
                        if (name == "\\rmdefault")
                                if (is_known(body, known_roman_fonts)) {
-                                       h_font_roman = body;
+                                       h_font_roman[0] = body;
                                        p.skip_spaces();
                                        in_lyx_preamble = true;
                                }
                        if (name == "\\sfdefault")
                                if (is_known(body, known_sans_fonts)) {
-                                       h_font_sans = body;
+                                       h_font_sans[0] = body;
                                        p.skip_spaces();
                                        in_lyx_preamble = true;
                                }
                        if (name == "\\ttdefault")
                                if (is_known(body, known_typewriter_fonts)) {
-                                       h_font_typewriter = body;
+                                       h_font_typewriter[0] = body;
                                        p.skip_spaces();
                                        in_lyx_preamble = true;
                                }
@@ -1552,9 +1634,12 @@ void Preamble::parse(Parser & p, string const & forceclass,
                                in_lyx_preamble = true;
                        }
 
-                       // remove the lyxdot definition that is re-added by LyX
+                       // remove LyX-specific definitions that are re-added by LyX
                        // if necessary
-                       if (name == "\\lyxdot") {
+                       // \lyxline is an ancient command that is converted by tex2lyx into
+                       // a \rule therefore remove its preamble code
+                       if (name == "\\lyxdot" || name == "\\lyxarrow"
+                           || name == "\\lyxline" || name == "\\LyX") {
                                p.skip_spaces();
                                in_lyx_preamble = true;
                        }
@@ -1596,6 +1681,12 @@ void Preamble::parse(Parser & p, string const & forceclass,
                        handle_opt(opts, known_languages, h_language);
                        delete_opt(opts, known_languages);
 
+                       // math indentation
+                       if ((it = find(opts.begin(), opts.end(), "fleqn"))
+                                != opts.end()) {
+                               h_is_mathindent = "1";
+                               opts.erase(it);
+                       }
                        // paper orientation
                        if ((it = find(opts.begin(), opts.end(), "landscape")) != opts.end()) {
                                h_paperorientation = "landscape";
@@ -1645,16 +1736,18 @@ void Preamble::parse(Parser & p, string const & forceclass,
                        vector<string>::const_iterator end = vecnames.end();
                        for (; it != end; ++it)
                                handle_package(p, trimSpaceAndEol(*it), options,
-                                              in_lyx_preamble);
+                                              in_lyx_preamble, detectEncoding);
                }
 
                else if (t.cs() == "inputencoding") {
                        string const encoding = p.getArg('{','}');
                        Encoding const * const enc = encodings.fromLaTeXName(
                                encoding, Encoding::inputenc, true);
-                       if (!enc)
-                               cerr << "Unknown encoding " << encoding << ". Ignoring." << std::endl;
-                       else {
+                       if (!enc) {
+                               if (!detectEncoding)
+                                       cerr << "Unknown encoding " << encoding
+                                            << ". Ignoring." << std::endl;
+                       } else {
                                if (!enc->unsafe())
                                        h_inputencoding = enc->name();
                                p.setEncoding(enc->iconvName());
@@ -1689,17 +1782,8 @@ void Preamble::parse(Parser & p, string const & forceclass,
 
                        add_known_theorem(name, opt1, !opt2.empty(), from_utf8(complete));
 
-                       // we know that our theorem module already add automatically some
-                       // theorem definition. They must not be output in the preamble to
-                       // avoid LaTeX errors about redefinitions
-                       if (complete == "\\newtheorem{thm}{\\protect\\theoremname}")
-                               in_lyx_preamble = true;
-                       else
-                               in_lyx_preamble = false;
-
                        if (!in_lyx_preamble)
-                               h_preamble << "\\newtheorem{" << name << '}'
-                                          << opt1 << opt2 << '{' << body << '}' << opt3;
+                               h_preamble << complete;
                }
 
                else if (t.cs() == "def") {
@@ -1760,6 +1844,8 @@ void Preamble::parse(Parser & p, string const & forceclass,
                                        h_defskip = "bigskip";
                                else
                                        h_defskip = translate_len(content);
+                       } else if (name == "\\mathindent") {
+                               h_mathindentation = translate_len(content);
                        } else
                                h_preamble << "\\setlength{" << name << "}{" << content << "}";
                }
@@ -1946,6 +2032,16 @@ void Preamble::parse(Parser & p, string const & forceclass,
 }
 
 
+string Preamble::parseEncoding(Parser & p, string const & forceclass)
+{
+       TeX2LyXDocClass dummy;
+       parse(p, forceclass, true, dummy);
+       if (h_inputencoding != "auto" && h_inputencoding != "default")
+               return h_inputencoding;
+       return "";
+}
+
+
 string babel2lyx(string const & language)
 {
        char const * const * where = is_known(language, known_languages);