]> git.lyx.org Git - lyx.git/blobdiff - src/BufferParams.cpp
* cs.po
[lyx.git] / src / BufferParams.cpp
index da35db18473666fd2e2e3a6944cec4cc7e17b0b8..11a78424895227a018d2d6747858a8dcdf368dfe 100644 (file)
@@ -1602,7 +1602,7 @@ bool BufferParams::writeLaTeX(otexstream & os, LaTeXFeatures & features,
                && papersize != PAPER_A5
                && papersize != PAPER_B5;
 
-       if (!use_geometry) {
+       if (!use_geometry || features.isProvided("geometry-light")) {
                switch (papersize) {
                case PAPER_A4:
                        clsoptions << "a4paper,";
@@ -1722,17 +1722,60 @@ bool BufferParams::writeLaTeX(otexstream & os, LaTeXFeatures & features,
        if (!options.empty()) {
                clsoptions << options << ',';
        }
-
-       string strOptions(clsoptions.str());
+       
+       docstring const strOptions = from_utf8(clsoptions.str());
        if (!strOptions.empty()) {
-               strOptions = rtrim(strOptions, ",");
-               // FIXME UNICODE
-               os << '[' << from_utf8(strOptions) << ']';
+               // Check if class options contain uncodable glyphs
+               docstring uncodable_glyphs;
+               docstring options_encodable;
+               Encoding const * const enc = features.runparams().encoding;
+               if (enc) {
+                       for (size_t n = 0; n < strOptions.size(); ++n) {
+                               char_type c = strOptions[n];
+                               if (!enc->encodable(c)) {
+                                       docstring const glyph(1, c);
+                                       LYXERR0("Uncodable character '"
+                                               << glyph
+                                               << "' in class options!");
+                                       uncodable_glyphs += glyph;
+                                       if (features.runparams().dryrun) {
+                                               options_encodable += "<" + _("LyX Warning: ")
+                                                  + _("uncodable character") + " '";
+                                               options_encodable += c;
+                                               options_encodable += "'>";
+                                       }
+                               } else
+                                       options_encodable += c;
+                       }
+               } else
+                       options_encodable = strOptions;
+       
+               // On BUFFER_VIEW|UPDATE, warn user if we found uncodable glyphs
+               if (!features.runparams().dryrun && !uncodable_glyphs.empty()) {
+                       frontend::Alert::warning(
+                               _("Uncodable character in class options"),
+                               support::bformat(
+                                 _("The class options of your document contain glyphs "
+                                   "that are unknown in the current document encoding "
+                                   "(namely %1$s).\nThese glyphs are omitted "
+                                   " from the output, which may result in "
+                                   "incomplete output."
+                                   "\n\nPlease select an appropriate "
+                                   "document encoding\n"
+                                   "(such as utf8) or change the "
+                                   "class options accordingly."),
+                                 uncodable_glyphs));
+               }
+               options_encodable = rtrim(options_encodable, ",");
+               os << '[' << options_encodable << ']';
        }
 
        os << '{' << from_ascii(tclass.latexname()) << "}\n";
        // end of \documentclass defs
 
+       // The package options (via \PassOptionsToPackage)
+       os << from_ascii(features.getPackageOptions());
+
        // if we use fontspec or newtxmath, we have to load the AMS packages here
        string const ams = features.loadAMSPackages();
        bool const ot1 = (main_font_encoding() == "default" || main_font_encoding() == "OT1");
@@ -1804,7 +1847,7 @@ bool BufferParams::writeLaTeX(otexstream & os, LaTeXFeatures & features,
        }
 
        if (!features.isProvided("geometry")
-           && (use_geometry || nonstandard_papersize)) {
+            && (use_geometry || nonstandard_papersize)) {
                odocstringstream ods;
                if (!getGraphicsDriver("geometry").empty())
                        ods << getGraphicsDriver("geometry");
@@ -1915,31 +1958,42 @@ bool BufferParams::writeLaTeX(otexstream & os, LaTeXFeatures & features,
                case PAPER_DEFAULT:
                        break;
                }
-               docstring const g_options = trim(ods.str(), ",");
+               docstring g_options = trim(ods.str(), ",");
                os << "\\usepackage";
-               if (!g_options.empty())
+               // geometry-light means that the class works with geometry, but overwrites
+               // the package options and paper sizes (memoir does this).
+               // In this case, all options need to go to \geometry
+               // and the standard paper sizes need to go to the class options.
+               if (!g_options.empty() && !features.isProvided("geometry-light")) {
                        os << '[' << g_options << ']';
+                       g_options.clear();
+               }
                os << "{geometry}\n";
-               // output this only if use_geometry is true
-               if (use_geometry) {
+               if (use_geometry || features.isProvided("geometry-light")) {
                        os << "\\geometry{verbose";
-                       if (!topmargin.empty())
-                               os << ",tmargin=" << from_ascii(Length(topmargin).asLatexString());
-                       if (!bottommargin.empty())
-                               os << ",bmargin=" << from_ascii(Length(bottommargin).asLatexString());
-                       if (!leftmargin.empty())
-                               os << ",lmargin=" << from_ascii(Length(leftmargin).asLatexString());
-                       if (!rightmargin.empty())
-                               os << ",rmargin=" << from_ascii(Length(rightmargin).asLatexString());
-                       if (!headheight.empty())
-                               os << ",headheight=" << from_ascii(Length(headheight).asLatexString());
-                       if (!headsep.empty())
-                               os << ",headsep=" << from_ascii(Length(headsep).asLatexString());
-                       if (!footskip.empty())
-                               os << ",footskip=" << from_ascii(Length(footskip).asLatexString());
-                       if (!columnsep.empty())
-                               os << ",columnsep=" << from_ascii(Length(columnsep).asLatexString());
-                       os << "}\n";
+                       if (!g_options.empty())
+                               // Output general options here with "geometry light".
+                               os << "," << g_options;
+                       // output this only if use_geometry is true
+                       if (use_geometry) {
+                               if (!topmargin.empty())
+                                       os << ",tmargin=" << from_ascii(Length(topmargin).asLatexString());
+                               if (!bottommargin.empty())
+                                       os << ",bmargin=" << from_ascii(Length(bottommargin).asLatexString());
+                               if (!leftmargin.empty())
+                                       os << ",lmargin=" << from_ascii(Length(leftmargin).asLatexString());
+                               if (!rightmargin.empty())
+                                       os << ",rmargin=" << from_ascii(Length(rightmargin).asLatexString());
+                               if (!headheight.empty())
+                                       os << ",headheight=" << from_ascii(Length(headheight).asLatexString());
+                               if (!headsep.empty())
+                                       os << ",headsep=" << from_ascii(Length(headsep).asLatexString());
+                               if (!footskip.empty())
+                                       os << ",footskip=" << from_ascii(Length(footskip).asLatexString());
+                               if (!columnsep.empty())
+                                       os << ",columnsep=" << from_ascii(Length(columnsep).asLatexString());
+                       }
+               os << "}\n";
                }
        } else if (orientation == ORIENTATION_LANDSCAPE
                   || papersize != PAPER_DEFAULT) {
@@ -2039,9 +2093,6 @@ bool BufferParams::writeLaTeX(otexstream & os, LaTeXFeatures & features,
                        os << "\\synctex=-1\n";
        }
 
-       // The package options (via \PassOptionsToPackage)
-       os << from_ascii(features.getPackageOptions());
-
        // due to interferences with babel and hyperref, the color package has to
        // be loaded (when it is not already loaded) before babel when hyperref
        // is used with the colorlinks option, see
@@ -2308,6 +2359,10 @@ bool BufferParams::writeLaTeX(otexstream & os, LaTeXFeatures & features,
                os << "\\usepackage{xunicode}\n";
        }
 
+       // covington must be loaded after beamerarticle
+       if (features.isRequired("covington"))
+           os << "\\usepackage{covington}\n";
+
        // Polyglossia must be loaded last ...
        if (use_polyglossia) {
                // call the package
@@ -2449,7 +2504,7 @@ void BufferParams::setDocumentClass(DocumentClassConstPtr tc)
 }
 
 
-bool BufferParams::setBaseClass(string const & classname)
+bool BufferParams::setBaseClass(string const & classname, string const & path)
 {
        LYXERR(Debug::TCLASS, "setBaseClass: " << classname);
        LayoutFileList & bcl = LayoutFileList::get();
@@ -2465,7 +2520,7 @@ bool BufferParams::setBaseClass(string const & classname)
                bcl.addEmptyClass(classname);
        }
 
-       bool const success = bcl[classname].load();
+       bool const success = bcl[classname].load(path);
        if (!success) {
                docstring s =
                        bformat(_("Due to some error in it, the layout file:\n"
@@ -3279,7 +3334,7 @@ void BufferParams::writeEncodingPreamble(otexstream & os,
                // Load the CJK package if needed by a secondary language.
                // If the main encoding is some variant of UTF8, use CJKutf8.
                if (encoding().package() != Encoding::CJK && features.mustProvide("CJK")) {
-                       if (encoding().iconvName() == "UTF-8"
+                       if (language->encoding()->name() == "utf8-cjk"
                            && LaTeXFeatures::isAvailable("CJKutf8"))
                                os << "\\usepackage{CJKutf8}\n";
                        else
@@ -3562,4 +3617,16 @@ void BufferParams::invalidateConverterCache() const
        pimpl_->isViewCacheValid = false;
 }
 
+
+// We shouldn't need to reset the params here, since anything
+// we need will be recopied.
+void BufferParams::copyForAdvFR(const BufferParams & bp)
+{
+       string const & lang = bp.language->lang();
+       setLanguage(lang);
+       layout_modules_ = bp.layout_modules_;
+       string const & doc_class = bp.documentClass().name();
+       setBaseClass(doc_class);
+}
+
 } // namespace lyx