Do not overwrite read-only files. We now move the file to the backup directory and...

[lyx.git] / src / BufferParams.cpp

diff --git a/src/BufferParams.cpp b/src/BufferParams.cpp
index 9630d631198a126f2abc78de40d2ccfc576a9f5e..c09f5bbbad1e8c5849c11dfa8782899736913950 100644 (file)
--- a/src/BufferParams.cpp
+++ b/src/BufferParams.cpp
@@ -1120,6 +1120,7 @@ void BufferParams::validate(LaTeXFeatures & features) const
                                features.require("ct-none");
                        }
                        break;
+               case OutputParams::LUATEX:
                case OutputParams::PDFLATEX:
                case OutputParams::XETEX:
                        if (xcolorulem) {
@@ -1187,8 +1188,8 @@ void BufferParams::validate(LaTeXFeatures & features) const
                        features.require("color");
        }
 
-       if (useXetex)
-               features.require("xetex");
+       if (features.runparams().flavor == OutputParams::XETEX)
+               features.require("polyglossia");
 
        if (language->lang() == "vietnamese")
                features.require("vietnamese");
@@ -1305,15 +1306,16 @@ bool BufferParams::writeLaTeX(odocstream & os, LaTeXFeatures & features,
 
        ostringstream language_options;
        bool const use_babel = features.useBabel() && !tclass.provides("babel");
-       if (use_babel) {
+       bool const use_polyglossia = features.usePolyglossia();
+       bool const global = lyxrc.language_global_options;
+       if (use_babel || (use_polyglossia && global)) {
                language_options << features.getLanguages();
                if (!language->babel().empty()) {
                        if (!language_options.str().empty())
                                language_options << ',';
                        language_options << language->babel();
                }
-               if (lyxrc.language_global_options
-                   && !features.needBabelLangOptions())
+               if (global && !features.needBabelLangOptions())
                        clsoptions << language_options.str() << ',';
        }
 
@@ -1358,9 +1360,9 @@ bool BufferParams::writeLaTeX(odocstream & os, LaTeXFeatures & features,
        // set font encoding
        // for arabic_arabi and farsi we also need to load the LAE and
        // LFE encoding
-       // XeTeX works without fontenc
+       // XeTeX and LuaTeX (isFullUnicode() flavor) work without fontenc
        if (font_encoding() != "default" && language->lang() != "japanese"
-           && !useXetex && !tclass.provides("fontenc")) {
+           && !features.runparams().isFullUnicode() && !tclass.provides("fontenc")) {
                size_t fars = language_options.str().find("farsi");
                size_t arab = language_options.str().find("arabic");
                if (language->lang() == "arabic_arabi"
@@ -1721,15 +1723,15 @@ bool BufferParams::writeLaTeX(odocstream & os, LaTeXFeatures & features,
        
        // If we use hyperref, jurabib, japanese, or vietnamese, we have to call babel before them.
        if (use_babel
-               && (features.isRequired("jurabib")
-                       || features.isRequired("hyperref")
-                       || features.isRequired("vietnamese")
-                       || features.isRequired("japanese") ) ) {
-                               // FIXME UNICODE
-                               lyxpreamble += from_utf8(features.getBabelPresettings());
-                               lyxpreamble += from_utf8(babelCall(language_options.str(),
-                                                                  features.needBabelLangOptions())) + '\n';
-                               lyxpreamble += from_utf8(features.getBabelPostsettings());
+           && (features.isRequired("jurabib")
+               || features.isRequired("hyperref")
+               || features.isRequired("vietnamese")
+               || features.isRequired("japanese"))) {
+                       // FIXME UNICODE
+                       lyxpreamble += from_utf8(features.getBabelPresettings());
+                       lyxpreamble += from_utf8(babelCall(language_options.str(),
+                                                          features.needBabelLangOptions())) + '\n';
+                       lyxpreamble += from_utf8(features.getBabelPostsettings());
        }
 
        // The optional packages;
@@ -1877,6 +1879,7 @@ bool BufferParams::writeLaTeX(odocstream & os, LaTeXFeatures & features,
                lyxpreamble += from_utf8(features.getBabelPostsettings());
        }
 
+       // FIXME Polyglossia?
        docstring const i18npreamble = features.getTClassI18nPreamble(use_babel);
        if (!i18npreamble.empty())
                lyxpreamble += i18npreamble + '\n';
@@ -1890,12 +1893,35 @@ bool BufferParams::writeLaTeX(odocstream & os, LaTeXFeatures & features,
        // these packages (xunicode, for that matter) need to be loaded at least
        // after amsmath, amssymb, esint and the other packages that provide 
        // special glyphs
-       if (useXetex) {
+       if (features.runparams().flavor == OutputParams::XETEX) {
                os << "\\usepackage{xunicode}\n";
                texrow.newline();
                os << "\\usepackage{xltxtra}\n";
                texrow.newline();
        }
+       // Polyglossia must be loaded after xltxtra
+       if (use_polyglossia) {
+               // call the package
+               os << "\\usepackage{polyglossia}\n";
+               texrow.newline();
+               // set the main language
+               os << "\\setdefaultlanguage";
+               if (!language->polyglossiaOpts().empty())
+                       os << "[" << from_ascii(language->polyglossiaOpts()) << "]";
+               os << "{" + from_ascii(language->polyglossia()) + "}\n";
+               texrow.newline();
+               // now setup the other languages
+               std::map<std::string, std::string> const polylangs = 
+                       features.getPolyglossiaLanguages();
+               for (std::map<std::string, std::string>::const_iterator mit = polylangs.begin();
+                    mit != polylangs.end() ; ++mit) {
+                       os << "\\setotherlanguage";
+                       if (!mit->second.empty())
+                               os << "[" << from_ascii(mit->second) << "]";
+                       os << "{" << from_ascii(mit->first) << "}\n";
+                       texrow.newline();
+               }
+       }
        return use_babel;
 }
 
@@ -2394,9 +2420,8 @@ string const BufferParams::font_encoding() const
 
 string BufferParams::babelCall(string const & lang_opts, bool const langoptions) const
 {
-       string lang_pack = lyxrc.language_package;
-       if (lang_pack != "\\usepackage{babel}")
-               return lang_pack;
+       if (lyxrc.language_package_selection == LyXRC::LP_CUSTOM)
+               return lyxrc.language_custom_package;
        // suppress the babel call if there is no BabelName defined
        // for the document language in the lib/languages file and if no
        // other languages are used (lang_opts is then empty)
@@ -2407,7 +2432,7 @@ string BufferParams::babelCall(string const & lang_opts, bool const langoptions)
        // be submitted to babel itself (not the class).
        if (langoptions)
                return "\\usepackage[" + lang_opts + "]{babel}";
-       return lang_pack;
+       return "\\usepackage{babel}";
 }
 
 
@@ -2432,7 +2457,8 @@ docstring BufferParams::getGraphicsDriver(string const & package) const
 void BufferParams::writeEncodingPreamble(odocstream & os,
                LaTeXFeatures & features, TexRow & texrow) const
 {
-       if (useXetex)
+       // fully unicode-aware backends (such as XeTeX) do not need this
+       if (features.runparams().isFullUnicode())
                return;
        if (inputenc == "auto") {
                string const doc_encoding =
@@ -2548,9 +2574,12 @@ string const BufferParams::loadFonts(string const & rm,
        ostringstream os;
 
        if (xetex) {
-               if (rm != "default")
-                       os << "\\setmainfont[Mapping=tex-text]{"
-                          << parseFontName(rm) << "}\n";
+               if (rm != "default") {
+                       os << "\\setmainfont[Mapping=tex-text";
+                       if (osf)
+                               os << ",Numbers=OldStyle";
+                       os << "]{" << parseFontName(rm) << "}\n";
+               }
                if (sf != "default") {
                        string const sans = parseFontName(sf);
                        if (sfscale != 100)
@@ -2573,8 +2602,6 @@ string const BufferParams::loadFonts(string const & rm,
                                os << "\\setmonofont[Mapping=tex-text]{"
                                   << mono << "}\n";
                }
-               if (osf)
-                       os << "\\defaultfontfeatures{Numbers=OldStyle}\n";
                return os.str();
        }