Update cursor idx after grid paste if columns are appended

[lyx.git] / src / BufferParams.cpp

diff --git a/src/BufferParams.cpp b/src/BufferParams.cpp
index e266a0fdabe10d18c2d0758067644334b38e6b17..1b130748d07c780c70fa39e65336f08247ea9380 100644 (file)
--- a/src/BufferParams.cpp
+++ b/src/BufferParams.cpp
@@ -1724,12 +1724,52 @@ 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";
@@ -1963,26 +2003,36 @@ bool BufferParams::writeLaTeX(otexstream & os, LaTeXFeatures & features,
 
        if (paragraph_separation) {
                // when skip separation
+               string psopt;
                switch (getDefSkip().kind()) {
                case VSpace::SMALLSKIP:
-                       os << "\\setlength{\\parskip}{\\smallskipamount}\n";
+                       psopt = "\\smallskipamount";
                        break;
                case VSpace::MEDSKIP:
-                       os << "\\setlength{\\parskip}{\\medskipamount}\n";
+                       psopt = "\\medskipamount";
                        break;
                case VSpace::BIGSKIP:
-                       os << "\\setlength{\\parskip}{\\bigskipamount}\n";
+                       psopt = "\\bigskipamount";
+                       break;
+               case VSpace::HALFLINE:
+                       // default (no option)
+                       break;
+               case VSpace::FULLLINE:
+                       psopt = "\\baselineskip";
                        break;
                case VSpace::LENGTH:
-                       os << "\\setlength{\\parskip}{"
-                          << from_utf8(getDefSkip().length().asLatexString())
-                          << "}\n";
+                       psopt = getDefSkip().length().asLatexString();
                        break;
-               default: // should never happen // Then delete it.
-                       os << "\\setlength{\\parskip}{\\medskipamount}\n";
+               default:
                        break;
                }
-               os << "\\setlength{\\parindent}{0pt}\n";
+               if (!features.isProvided("parskip")) {
+                       if (!psopt.empty())
+                               psopt = "[skip=" + psopt + "]";
+                       os << "\\usepackage" + psopt + "{parskip}\n";
+               } else {
+                       os << "\\setlength{\\parskip}{" + psopt + "}\n";
+               }
        } else {
                // when separation by indentation
                // only output something when a width is given