]> git.lyx.org Git - lyx.git/blobdiff - src/paragraph_pimpl.C
* support/qstring_helpers.h: erase ucs4_to_qstring() method.
[lyx.git] / src / paragraph_pimpl.C
index 426862c246e3f8d04151b46d8ac03ef240cc1268..900837a49a80d2c26e790ef0de5d81f4f2f965e5 100644 (file)
@@ -58,6 +58,18 @@ special_phrase const special_phrases[] = {
 
 size_t const phrases_nr = sizeof(special_phrases)/sizeof(special_phrase);
 
+
+/// Get the real encoding of a character with font \p font.
+/// doc_encoding == bparams.encoding(), but we use a precomputed variable
+/// since bparams.encoding() is expensive
+inline Encoding const & getEncoding(BufferParams const & bparams,
+               Encoding const & doc_encoding, LyXFont const & font)
+{
+       if (bparams.inputenc == "auto" || bparams.inputenc == "default")
+               return *(font.language()->encoding());
+       return doc_encoding;
+}
+
 } // namespace anon
 
 
@@ -87,6 +99,19 @@ bool Paragraph::Pimpl::isChanged(pos_type start, pos_type end) const
 }
 
 
+bool Paragraph::Pimpl::isMergedOnEndOfParDeletion(bool trackChanges) const {
+       // keep the logic here in sync with the logic of eraseChars()
+
+       if (!trackChanges) {
+               return true;
+       }
+
+       Change change = changes_.lookup(size());
+
+       return change.type == Change::INSERTED && change.author == 0;
+}
+
+
 void Paragraph::Pimpl::setChange(Change const & change)
 {
        // beware of the imaginary end-of-par character!
@@ -129,7 +154,7 @@ void Paragraph::Pimpl::setChange(pos_type pos, Change const & change)
 }
 
 
-Change const Paragraph::Pimpl::lookupChange(pos_type pos) const
+Change const Paragraph::Pimpl::lookupChange(pos_type pos) const
 {
        BOOST_ASSERT(pos >= 0 && pos <= size());
 
@@ -137,18 +162,27 @@ Change const Paragraph::Pimpl::lookupChange(pos_type pos) const
 }
 
 
-void Paragraph::Pimpl::acceptChanges(pos_type start, pos_type end)
+void Paragraph::Pimpl::acceptChanges(BufferParams const & bparams, pos_type start, pos_type end)
 {
        BOOST_ASSERT(start >= 0 && start <= size());
        BOOST_ASSERT(end > start && end <= size() + 1);
-       
+
        for (pos_type pos = start; pos < end; ++pos) {
                switch (lookupChange(pos).type) {
                        case Change::UNCHANGED:
+                               // accept changes in nested inset
+                               if (pos < size() && owner_->isInset(pos)) {
+                                       owner_->getInset(pos)->acceptChanges(bparams);
+                               }
+
                                break;
 
                        case Change::INSERTED:
                                changes_.set(Change(Change::UNCHANGED), pos);
+                               // also accept changes in nested inset
+                               if (pos < size() && owner_->isInset(pos)) {
+                                       owner_->getInset(pos)->acceptChanges(bparams);
+                               }
                                break;
 
                        case Change::DELETED:
@@ -162,15 +196,11 @@ void Paragraph::Pimpl::acceptChanges(pos_type start, pos_type end)
                                break;
                }
 
-               // also accept changes in nested insets
-               if (pos < size() && owner_->isInset(pos)) {
-                       owner_->getInset(pos)->acceptChanges();
-               }
        }
 }
 
 
-void Paragraph::Pimpl::rejectChanges(pos_type start, pos_type end)
+void Paragraph::Pimpl::rejectChanges(BufferParams const & bparams, pos_type start, pos_type end)
 {
        BOOST_ASSERT(start >= 0 && start <= size());
        BOOST_ASSERT(end > start && end <= size() + 1);
@@ -178,9 +208,9 @@ void Paragraph::Pimpl::rejectChanges(pos_type start, pos_type end)
        for (pos_type pos = start; pos < end; ++pos) {
                switch (lookupChange(pos).type) {
                        case Change::UNCHANGED:
-                               // also reject changes inside of insets
+                               // reject changes in nested inset
                                if (pos < size() && owner_->isInset(pos)) {
-                                       owner_->getInset(pos)->rejectChanges();
+                                       owner_->getInset(pos)->rejectChanges(bparams);
                                }
                                break;
 
@@ -263,6 +293,8 @@ bool Paragraph::Pimpl::eraseChar(pos_type pos, bool trackChanges)
 {
        BOOST_ASSERT(pos >= 0 && pos <= size());
 
+       // keep the logic here in sync with the logic of isMergedOnEndOfParDeletion()
+
        if (trackChanges) {
                Change change = changes_.lookup(pos);
 
@@ -348,16 +380,47 @@ int Paragraph::Pimpl::eraseChars(pos_type start, pos_type end, bool trackChanges
 }
 
 
-void Paragraph::Pimpl::simpleTeXBlanks(odocstream & os, TexRow & texrow,
-                                      pos_type const i,
+int Paragraph::Pimpl::latexSurrogatePair(odocstream & os, value_type c,
+               value_type next, Encoding const & encoding)
+{
+       // Writing next here may circumvent a possible font change between
+       // c and next. Since next is only output if it forms a surrogate pair
+       // with c we can ignore this:
+       // A font change inside a surrogate pair does not make sense and is
+       // hopefully impossible to input.
+       // FIXME: change tracking
+       // Is this correct WRT change tracking?
+       docstring const latex1 = encoding.latexChar(next);
+       docstring const latex2 = encoding.latexChar(c);
+       os << latex1 << '{' << latex2 << '}';
+       return latex1.length() + latex2.length() + 2;
+}
+
+
+bool Paragraph::Pimpl::simpleTeXBlanks(BufferParams const & bparams,
+                                       Encoding const & doc_encoding,
+                                       odocstream & os, TexRow & texrow,
+                                       pos_type & i,
                                       unsigned int & column,
                                       LyXFont const & font,
                                       LyXLayout const & style)
 {
        if (style.pass_thru)
-               return;
+               return false;
 
-       if (column > lyxrc.ascii_linelen
+       if (i < size() - 1) {
+               char_type next = getChar(i + 1);
+               if (Encodings::isCombiningChar(next)) {
+                       // This space has an accent, so we must always output it.
+                       Encoding const & encoding = getEncoding(bparams, doc_encoding, font);
+                       column += latexSurrogatePair(os, ' ', next, encoding) - 1;
+                       ++i;
+                       return true;
+               }
+       }
+
+       if (lyxrc.plaintext_linelen > 0
+           && column > lyxrc.plaintext_linelen
            && i
            && getChar(i - 1) != ' '
            && (i < size() - 1)
@@ -379,6 +442,7 @@ void Paragraph::Pimpl::simpleTeXBlanks(odocstream & os, TexRow & texrow,
        } else {
                os << ' ';
        }
+       return false;
 }
 
 
@@ -392,6 +456,8 @@ bool Paragraph::Pimpl::isTextAt(string const & str, pos_type pos) const
 
        // does the wanted text start at point?
        for (string::size_type i = 0; i < str.length(); ++i) {
+               // Caution: direct comparison of characters works only
+               // because str is pure ASCII.
                if (str[i] != owner_->text_[pos + i])
                        return false;
        }
@@ -412,6 +478,7 @@ bool Paragraph::Pimpl::isTextAt(string const & str, pos_type pos) const
 
 void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
                                             BufferParams const & bparams,
+                                            Encoding const & doc_encoding,
                                             odocstream & os,
                                             TexRow & texrow,
                                             OutputParams const & runparams,
@@ -429,6 +496,8 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
        if (style.pass_thru) {
                if (c != Paragraph::META_INSET) {
                        if (c != '\0')
+                               // FIXME UNICODE: This can fail if c cannot
+                               // be encoded in the current encoding.
                                os.put(c);
                } else
                        owner_->getInset(i)->plaintext(buf, os, runparams);
@@ -454,7 +523,8 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
                                os << '\n';
                        } else {
                                if (open_font) {
-                                       column += running_font.latexWriteEndChanges(os, basefont, basefont);
+                                       column += running_font.latexWriteEndChanges(
+                                               os, basefont, basefont, bparams);
                                        open_font = false;
                                }
                                basefont = owner_->getLayoutFont(bparams, outerfont);
@@ -507,10 +577,8 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
 #endif
                // some insets cannot be inside a font change command
                if (open_font && inset->noFontChange()) {
-                       column +=running_font.
-                               latexWriteEndChanges(os,
-                                                    basefont,
-                                                    basefont);
+                       column += running_font.latexWriteEndChanges(
+                                       os, basefont, basefont, bparams);
                        open_font = false;
                        basefont = owner_->getLayoutFont(bparams, outerfont);
                        running_font = basefont;
@@ -546,30 +614,6 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
                // would be wrongly converted on systems where char is signed, so we give
                // the code points.
                // This also makes us independant from the encoding of this source file.
-               case 0xb1:    // ± PLUS-MINUS SIGN
-               case 0xb2:    // ² SUPERSCRIPT TWO
-               case 0xb3:    // ³ SUPERSCRIPT THREE
-               case 0xd7:    // × MULTIPLICATION SIGN
-               case 0xf7:    // ÷ DIVISION SIGN
-               case 0xb9:    // ¹ SUPERSCRIPT ONE
-               case 0xac:    // ¬ NOT SIGN
-               case 0xb5:    // µ MICRO SIGN
-                       if ((bparams.inputenc == "latin1" ||
-                            bparams.inputenc == "latin9") ||
-                           (bparams.inputenc == "auto" &&
-                            (font.language()->encoding()->latexName()
-                             == "latin1" ||
-                             font.language()->encoding()->latexName()
-                             == "latin9"))) {
-                               os << "\\ensuremath{";
-                               os.put(c);
-                               os << '}';
-                               column += 13;
-                       } else {
-                               os.put(c);
-                       }
-                       break;
-
                case '|': case '<': case '>':
                        // In T1 encoding, these characters exist
                        if (lyxrc.fontenc == "T1") {
@@ -579,12 +623,13 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
                                    && i <= size() - 2
                                    && getChar(i + 1) == c) {
                                        //os << "\\textcompwordmark{}";
+                                       //column += 19;
                                        // Jean-Marc, have a look at
                                        // this. I think this works
                                        // equally well:
                                        os << "\\,{}";
                                        // Lgb
-                                       column += 19;
+                                       column += 3;
                                }
                                break;
                        }
@@ -627,15 +672,6 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
                        column += 9;
                        break;
 
-               case 0xa3:    // £ POUND SIGN
-                       if (bparams.inputenc == "default") {
-                               os << "\\pounds{}";
-                               column += 8;
-                       } else {
-                               os.put(c);
-                       }
-                       break;
-
                case '$': case '&':
                case '%': case '#': case '{':
                case '}': case '_':
@@ -673,6 +709,8 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
                default:
 
                        // I assume this is hack treating typewriter as verbatim
+                       // FIXME UNICODE: This can fail if c cannot be encoded
+                       // in the current encoding.
                        if (font.family() == LyXFont::TYPEWRITER_FAMILY) {
                                if (c != '\0') {
                                        os.put(c);
@@ -700,7 +738,27 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf,
                        }
 
                        if (pnr == phrases_nr && c != '\0') {
-                               os.put(c);
+                               Encoding const & encoding = getEncoding(bparams, doc_encoding, font);
+                               if (i < size() - 1) {
+                                       char_type next = getChar(i + 1);
+                                       if (Encodings::isCombiningChar(next)) {
+                                               column += latexSurrogatePair(os, c, next, encoding) - 1;
+                                               ++i;
+                                               break;
+                                       }
+                               }
+                               docstring const latex = encoding.latexChar(c);
+                               if (latex.length() > 1 &&
+                                   latex[latex.length() - 1] != '}') {
+                                       // Prevent eating of a following
+                                       // space or command corruption by
+                                       // following characters
+                                       column += latex.length() + 1;
+                                       os << latex << "{}";
+                               } else {
+                                       column += latex.length() - 1;
+                                       os << latex;
+                               }
                        }
                        break;
                }
@@ -732,7 +790,7 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features,
                                             << endl;
                        features.require("noun");
                        lyxerr[Debug::LATEX] << "Noun enabled. Font: "
-                                            << fcit->font().stateText(0)
+                                            << to_utf8(fcit->font().stateText(0))
                                             << endl;
                }
                switch (fcit->font().color()) {
@@ -747,7 +805,7 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features,
                default:
                        features.require("color");
                        lyxerr[Debug::LATEX] << "Color enabled. Font: "
-                                            << fcit->font().stateText(0)
+                                            << to_utf8(fcit->font().stateText(0))
                                             << endl;
                }
 
@@ -778,6 +836,7 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features,
        }
 
        // then the contents
+       Encoding const & doc_encoding = bparams.encoding();
        for (pos_type i = 0; i < size() ; ++i) {
                for (size_t pnr = 0; pnr < phrases_nr; ++pnr) {
                        if (!special_phrases[pnr].builtin
@@ -786,6 +845,12 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features,
                                break;
                        }
                }
+               // We do not need the completely realized font, since we are
+               // only interested in the language, and that is never inherited.
+               // Therefore we can use getFontSettings instead of getFont.
+               LyXFont const & font = owner_->getFontSettings(bparams, i);
+               Encoding const & encoding = getEncoding(bparams, doc_encoding, font);
+               encoding.validate(getChar(i), features);
        }
 }