]> git.lyx.org Git - lyx.git/blobdiff - src/Paragraph.cpp
Move <QTimer> from TocWidget.h
[lyx.git] / src / Paragraph.cpp
index 4977c2f275624bc9628eda4d17395a16ebfc2e35..d69fa55bb539459b0760adc24d19724a6da75ec3 100644 (file)
 #include "Language.h"
 #include "LaTeXFeatures.h"
 #include "Layout.h"
-#include "Length.h"
 #include "Font.h"
 #include "FontList.h"
 #include "LyXRC.h"
 #include "OutputParams.h"
 #include "output_latex.h"
 #include "output_xhtml.h"
+#include "output_docbook.h"
 #include "ParagraphParameters.h"
 #include "SpellChecker.h"
-#include "sgml.h"
+#include "xml.h"
 #include "texstream.h"
 #include "TextClass.h"
 #include "TexRow.h"
 #include "support/ExceptionMessage.h"
 #include "support/gettext.h"
 #include "support/lassert.h"
+#include "support/Length.h"
 #include "support/lstrings.h"
 #include "support/textutils.h"
+#include "output_docbook.h"
 
+#include <algorithm>
 #include <atomic>
 #include <sstream>
 #include <vector>
@@ -82,14 +85,6 @@ using namespace lyx::support;
 
 namespace lyx {
 
-namespace {
-
-/// Inset identifier (above 0x10ffff, for ucs-4)
-char_type const META_INSET = 0x200001;
-
-} // namespace
-
-
 /////////////////////////////////////////////////////////////////////
 //
 // SpellResultRange
@@ -272,9 +267,9 @@ private:
        Ranges ranges_;
        /// the area of the paragraph with pending spell check
        FontSpan refresh_;
-       bool needs_refresh_;
        /// spell state cache version number
        SpellChecker::ChangeNumber current_change_number_;
+       bool needs_refresh_;
 
 
        void correctRangesAfterPos(pos_type pos, int offset)
@@ -329,15 +324,6 @@ public:
                             Font const & font,
                             Layout const & style);
 
-       /// Output consecutive unicode chars, belonging to the same script as
-       /// specified by the latex macro \p ltx, to \p os starting from \p i.
-       /// \return the number of characters written.
-       int writeScriptChars(BufferParams const &, OutputParams const &,
-                            otexstream & os,
-                            docstring const & ltx,
-                            Change const &, Encoding const &,
-                            std::string const, pos_type & i);
-
        /// This could go to ParagraphParameters if we want to.
        int startTeXParParams(BufferParams const &, otexstream &,
                              OutputParams const &) const;
@@ -357,7 +343,10 @@ public:
                                   Change & running_change,
                                   Layout const & style,
                                   pos_type & i,
-                                  unsigned int & column);
+                                  unsigned int & column,
+                                  bool const fontswitch_inset,
+                                  bool const closeLanguage,
+                                  bool const lang_switched_at_inset);
 
        ///
        void latexSpecialChar(
@@ -365,7 +354,7 @@ public:
                                   BufferParams const & bparams,
                                   OutputParams const & runparams,
                                   Font const & running_font,
-                                  Change const & running_change,
+                                  string & alien_script,
                                   Layout const & style,
                                   pos_type & i,
                                   pos_type end_pos,
@@ -454,10 +443,10 @@ public:
                        return;
                }
                pos_type endpos = last;
-               owner_->locateWord(first, endpos, WHOLE_WORD);
+               owner_->locateWord(first, endpos, WHOLE_WORD, true);
                if (endpos < last) {
                        endpos = last;
-                       owner_->locateWord(last, endpos, WHOLE_WORD);
+                       owner_->locateWord(last, endpos, WHOLE_WORD, true);
                }
                last = endpos;
        }
@@ -467,7 +456,7 @@ public:
        {
                int numskips = 0;
                while (it != et && it->first < start) {
-                       int skip = it->last - it->first + 1;
+                       long skip = it->last - it->first + 1;
                        start += skip;
                        numskips += skip;
                        ++it;
@@ -494,9 +483,6 @@ public:
        ///
        FontList fontlist_;
 
-       ///
-       int id_;
-
        ///
        ParagraphParameters params_;
 
@@ -521,11 +507,13 @@ public:
        Layout const * layout_;
        ///
        SpellCheckerState speller_state_;
+       ///
+       int id_;
 };
 
 
 Paragraph::Private::Private(Paragraph * owner, Layout const & layout)
-       : owner_(owner), inset_owner_(0), id_(-1), begin_of_body_(0), layout_(&layout)
+       : owner_(owner), inset_owner_(nullptr), begin_of_body_(0), layout_(&layout), id_(-1)
 {
        text_.reserve(100);
 }
@@ -538,17 +526,16 @@ int Paragraph::Private::make_id()
        // LFUN_PARAGRAPH_GOTO to switch to a different buffer, for instance in the
        // outliner.
        // (thread-safe)
-       static atomic_uint next_id(0);
+       static int next_id(0);
        return next_id++;
 }
 
 
 Paragraph::Private::Private(Private const & p, Paragraph * owner)
        : owner_(owner), inset_owner_(p.inset_owner_), fontlist_(p.fontlist_),
-         id_(make_id()),
          params_(p.params_), changes_(p.changes_), insetlist_(p.insetlist_),
          begin_of_body_(p.begin_of_body_), text_(p.text_), words_(p.words_),
-         layout_(p.layout_)
+         layout_(p.layout_), id_(make_id())
 {
        requestSpellCheck(p.text_.size());
 }
@@ -556,11 +543,11 @@ Paragraph::Private::Private(Private const & p, Paragraph * owner)
 
 Paragraph::Private::Private(Private const & p, Paragraph * owner,
        pos_type beg, pos_type end)
-       : owner_(owner), inset_owner_(p.inset_owner_), id_(make_id()),
+       : owner_(owner), inset_owner_(p.inset_owner_),
          params_(p.params_), changes_(p.changes_),
          insetlist_(p.insetlist_, beg, end),
          begin_of_body_(p.begin_of_body_), words_(p.words_),
-         layout_(p.layout_)
+         layout_(p.layout_), id_(make_id())
 {
        if (beg >= pos_type(p.text_.size()))
                return;
@@ -590,18 +577,6 @@ void Paragraph::addChangesToToc(DocIterator const & cdit, Buffer const & buf,
 }
 
 
-void Paragraph::addChangesToBuffer(Buffer const & buf) const
-{
-       d->changes_.updateBuffer(buf);
-}
-
-
-bool Paragraph::isChangeUpdateRequired() const
-{
-       return d->changes_.isUpdateRequired();
-}
-
-
 bool Paragraph::isDeleted(pos_type start, pos_type end) const
 {
        LASSERT(start >= 0 && start <= size(), return false);
@@ -619,6 +594,28 @@ bool Paragraph::isChanged(pos_type start, pos_type end) const
        return d->changes_.isChanged(start, end);
 }
 
+// FIXME: Ideally the diverse isChanged() methods should account for that!
+bool Paragraph::hasChangedInsets(pos_type start, pos_type end) const
+{
+       LASSERT(start >= 0 && start <= size(), return false);
+       LASSERT(end > start && end <= size() + 1, return false);
+
+       for (auto const & icit : d->insetlist_) {
+               if (icit.pos < start)
+                       continue;
+               if (icit.pos >= end)
+                       break;
+               if (icit.inset && icit.inset->isChanged())
+                       return true;
+       }
+       return false;
+}
+
+bool Paragraph::isChanged() const
+{
+       return d->changes_.isChanged();
+}
+
 
 bool Paragraph::isMergedOnEndOfParDeletion(bool trackChanges) const
 {
@@ -630,6 +627,11 @@ bool Paragraph::isMergedOnEndOfParDeletion(bool trackChanges) const
        return change.inserted() && change.currentAuthor();
 }
 
+Change Paragraph::parEndChange() const
+{
+       return d->changes_.lookup(size());
+}
+
 
 void Paragraph::setChange(Change const & change)
 {
@@ -664,8 +666,8 @@ void Paragraph::setChange(pos_type pos, Change const & change)
 
        // see comment in setChange(Change const &) above
        if (!change.deleted() && pos < size())
-                       if (Inset * inset = getInset(pos))
-                               inset->setChange(change);
+               if (Inset * inset = getInset(pos))
+                       inset->setChange(change);
 }
 
 
@@ -869,7 +871,7 @@ int Paragraph::eraseChars(pos_type start, pos_type end, bool trackChanges)
        return end - i;
 }
 
-
+// Handle combining characters
 int Paragraph::Private::latexSurrogatePair(BufferParams const & bparams,
                otexstream & os, char_type c, char_type next,
                OutputParams const & runparams)
@@ -891,61 +893,15 @@ int Paragraph::Private::latexSurrogatePair(BufferParams const & bparams,
        }
        docstring latex2 = encoding.latexChar(c).first;
 
-       // Handle combining characters in "script" context (i.e., \textgreek and \textcyrillic)
-       docstring::size_type const brace1 = latex2.find_first_of(from_ascii("{"));
-       docstring::size_type const brace2 = latex2.find_last_of(from_ascii("}"));
-       string script = to_ascii(latex2.substr(1, brace1 - 1));
-       // "Script chars" need to embraced in \textcyrillic and \textgreek notwithstanding
-       // whether they are encodable or not (it only depends on the font encoding),
-       // except if we are using fontspec.
-       bool scriptchar = false;
-       if (!bparams.useNonTeXFonts)
-               // This will get us a script value to deal with below
-               scriptchar = Encodings::isKnownScriptChar(c, script);
-
-       if (!scriptchar && docstring(1, next) == latex1) {
-               // The encoding supports the combination:
+       if (bparams.useNonTeXFonts || docstring(1, next) == latex1) {
+               // Encoding supports the combination:
                // output as is (combining char after base char).
                os << latex2 << latex1;
                return latex1.length() + latex2.length();
        }
 
-       int pos = 0;
-       int length = brace2;
-       string fontenc;
-       if (runparams.local_font)
-               fontenc = runparams.local_font->language()->fontenc(bparams);
-       else
-               fontenc = bparams.language->fontenc(bparams);
-       docstring scriptmacro;
-       docstring cb;
-       if (script == "textgreek" || script == "textcyrillic") {
-               // We separate the script macro (\text[greek|cyr]) from the rest,
-               // since we need to include the combining char in it (#6463).
-               // This is "the rest":
-               pos = brace1 + 1;
-               length -= pos;
-               latex2 = latex2.substr(pos, length);
-               // We only need the script macro with non-native font encodings
-               // and with XeTeX/LuaTeX (with TeX fonts)
-               if (Encodings::needsScriptWrapper(script, fontenc)
-                   || runparams.isFullUnicode()) {
-                       scriptmacro = from_ascii("\\" + script + "{");
-                       cb = from_ascii("}");
-               }
-       }
-
-       docstring lb;
-       docstring rb;
-       // polutonikogreek does not play nice with brackets
-       if (!runparams.local_font
-           || runparams.local_font->language()->lang() != "polutonikogreek") {
-               lb = from_ascii("{");
-               rb = from_ascii("}");
-       }
-
-       os << scriptmacro << latex1 << lb << latex2 << rb << cb;
-       return latex1.length() + latex2.length() + lb.length() + rb.length() + cb.length();
+       os << latex1 << "{" << latex2 << "}";
+       return latex1.length() + latex2.length() + 2;
 }
 
 
@@ -995,96 +951,6 @@ bool Paragraph::Private::simpleTeXBlanks(BufferParams const & bparams,
 }
 
 
-int Paragraph::Private::writeScriptChars(BufferParams const & bparams,
-                                        OutputParams const & runparams,
-                                        otexstream & os,
-                                        docstring const & ltx,
-                                        Change const & runningChange,
-                                        Encoding const & encoding,
-                                        string const fontenc,
-                                        pos_type & i)
-{
-       // FIXME: modifying i here is not very nice...
-
-       // We only arrive here when character text_[i] could not be translated
-       // into the current latex encoding (or its latex translation has been forced,)
-       // and it belongs to a known script.
-       // Parameter ltx contains the latex translation of text_[i] as specified
-       // in the unicodesymbols file and is something like "\textXXX{<spec>}".
-       // The latex macro name "textXXX" specifies the script to which text_[i]
-       // belongs and we use it in order to check whether characters from the
-       // same script immediately follow, such that we can collect them in a
-       // single "\textXXX" macro. So, we have to retain "\textXXX{<spec>"
-       // for the first char but only "<spec>" for all subsequent chars.
-       docstring::size_type const brace1 = ltx.find_first_of(from_ascii("{"));
-       docstring::size_type const brace2 = ltx.find_last_of(from_ascii("}"));
-       string script = to_ascii(ltx.substr(1, brace1 - 1));
-       int pos = 0;
-       int length = brace2;
-       bool closing_brace = true;
-       // We only need the script macro with non-native font encodings
-       // and with XeTeX/LuaTeX (with TeX fonts)
-       if (!Encodings::needsScriptWrapper(script, fontenc)
-           && !runparams.isFullUnicode()) {
-               // Correct font encoding is being used, so we can avoid \text[greek|cyr].
-               pos = brace1 + 1;
-               length -= pos;
-               closing_brace = false;
-       }
-       os << ltx.substr(pos, length);
-       int size = text_.size();
-       while (i + 1 < size) {
-               char_type const next = text_[i + 1];
-               // Stop here if next character belongs to another script
-               // or there is a change in change tracking status.
-               if (!Encodings::isKnownScriptChar(next, script) ||
-                   runningChange != owner_->lookupChange(i + 1))
-                       break;
-               Font prev_font;
-               bool found = false;
-               FontList::const_iterator cit = fontlist_.begin();
-               FontList::const_iterator end = fontlist_.end();
-               for (; cit != end; ++cit) {
-                       if (cit->pos() >= i && !found) {
-                               prev_font = cit->font();
-                               found = true;
-                       }
-                       if (cit->pos() >= i + 1)
-                               break;
-               }
-               // Stop here if there is a font attribute or encoding change.
-               if (found && cit != end && prev_font != cit->font())
-                       break;
-
-               // Check whether we have a combining pair
-               char_type next_next = '\0';
-               if (i + 2 < size) {
-                       next_next = text_[i + 2];
-                       if (Encodings::isCombiningChar(next_next)) {
-                               length += latexSurrogatePair(bparams, os, next, next_next, runparams) - 1;
-                               i += 2;
-                               continue;
-                       }
-               }
-
-               docstring const latex = encoding.latexChar(next).first;
-               docstring::size_type const b1 =
-                                       latex.find_first_of(from_ascii("{"));
-               docstring::size_type const b2 =
-                                       latex.find_last_of(from_ascii("}"));
-               int const len = b2 - b1 - 1;
-               os << latex.substr(b1 + 1, len);
-               length += len;
-               ++i;
-       }
-       if (closing_brace) {
-               os << '}';
-               ++length;
-       }
-       return length;
-}
-
-
 void Paragraph::Private::latexInset(BufferParams const & bparams,
                                    otexstream & os,
                                    OutputParams & runparams,
@@ -1095,7 +961,10 @@ void Paragraph::Private::latexInset(BufferParams const & bparams,
                                    Change & running_change,
                                    Layout const & style,
                                    pos_type & i,
-                                   unsigned int & column)
+                                   unsigned int & column,
+                                   bool const fontswitch_inset,
+                                   bool const closeLanguage,
+                                   bool const lang_switched_at_inset)
 {
        Inset * inset = owner_->getInset(i);
        LBUFERR(inset);
@@ -1150,7 +1019,7 @@ void Paragraph::Private::latexInset(BufferParams const & bparams,
        bool close = false;
        odocstream::pos_type const len = os.os().tellp();
 
-       if (inset->forceLTR()
+       if (inset->forceLTR(runparams)
            && running_font.isRightToLeft()
            // ERT is an exception, it should be output with no
            // decorations at all
@@ -1165,41 +1034,64 @@ void Paragraph::Private::latexInset(BufferParams const & bparams,
                close = true;
        }
 
-       // FIXME: Bug: we can have an empty font change here!
-       // if there has just been a font change, we are going to close it
-       // right now, which means stupid latex code like \textsf{}. AFAIK,
-       // this does not harm dvi output. A minor bug, thus (JMarc)
-
-       // Some insets cannot be inside a font change command.
-       // However, even such insets *can* be placed in \L or \R
-       // or their equivalents (for RTL language switches), so we don't
-       // close the language in those cases.
-       // ArabTeX, though, cannot handle this special behavior, it seems.
-       bool arabtex = basefont.language()->lang() == "arabic_arabtex"
-               || running_font.language()->lang() == "arabic_arabtex";
-       if (open_font && !inset->inheritFont()) {
-               bool needPar = false;
-               bool closeLanguage = arabtex
-                       || basefont.isRightToLeft() == running_font.isRightToLeft();
-               unsigned int count = running_font.latexWriteEndChanges(os,
-                                       bparams, runparams, basefont, basefont,
-                                       needPar, closeLanguage);
-               column += count;
-               // if any font properties were closed, update the running_font,
-               // making sure, however, to leave the language as it was
-               if (count > 0) {
-                       // FIXME: probably a better way to keep track of the old
-                       // language, than copying the entire font?
-                       Font const copy_font(running_font);
-                       basefont = owner_->getLayoutFont(bparams, outerfont);
-                       running_font = basefont;
-                       if (!closeLanguage)
-                               running_font.setLanguage(copy_font.language());
-                       // leave font open if language is still open
-                       open_font = (running_font.language() == basefont.language());
-                       if (closeLanguage)
-                               runparams.local_font = &basefont;
+       if (open_font && fontswitch_inset) {
+               bool lang_closed = false;
+               // Close language if needed
+               if (closeLanguage && !lang_switched_at_inset) {
+                       // We need prev_font here as language changes directly at inset
+                       // will only be started inside the inset.
+                       Font const prev_font = (i > 0) ?
+                                               owner_->getFont(bparams, i - 1, outerfont)
+                                             : running_font;
+                       Font tmpfont(basefont);
+                       tmpfont.setLanguage(prev_font.language());
+                       bool needPar = false;
+                       unsigned int count = tmpfont.latexWriteEndChanges(os, bparams, runparams,
+                                                                         basefont, basefont,
+                                                                         needPar, closeLanguage);
+                       column += count;
+                       lang_closed = count > 0;
                }
+               // Update the running_font, making sure, however,
+               // to leave the language as it was.
+               // FIXME: probably a better way to keep track of the old
+               // language, than copying the entire font?
+               Font const copy_font(running_font);
+               basefont = owner_->getLayoutFont(bparams, outerfont);
+               running_font = basefont;
+               if (!closeLanguage)
+                       running_font.setLanguage(copy_font.language());
+               OutputParams rp = runparams;
+               rp.encoding = basefont.language()->encoding();
+               // For these, we use switches, so they should be taken as
+               // base inside the inset.
+               basefont.fontInfo().setSize(copy_font.fontInfo().size());
+               basefont.fontInfo().setFamily(copy_font.fontInfo().family());
+               basefont.fontInfo().setSeries(copy_font.fontInfo().series());
+               // Now re-do font changes in a way needed here
+               // (using switches with multi-par insets)
+               InsetText const * textinset = inset->asInsetText();
+               bool const cprotect = textinset
+                       ? textinset->hasCProtectContent(runparams.moving_arg)
+                         && !textinset->text().isMainText()
+                       : false;
+               unsigned int count2 = basefont.latexWriteStartChanges(os, bparams,
+                                                     rp, running_font,
+                                                     basefont, true,
+                                                     cprotect);
+               open_font = true;
+               column += count2;
+               if (count2 == 0 && (lang_closed || lang_switched_at_inset))
+                       // All fonts closed
+                       open_font = false;
+               if (closeLanguage)
+                       runparams.local_font = &basefont;
+       }
+
+       if (fontswitch_inset && !closeLanguage) {
+               // The directionality has been switched at inset.
+               // Force markup inside.
+               runparams.local_font = &basefont;
        }
 
        size_t const previous_row_count = os.texrow().rows();
@@ -1212,7 +1104,7 @@ void Paragraph::Private::latexInset(BufferParams const & bparams,
                // add location information and throw again.
                e.par_id = id_;
                e.pos = i;
-               throw(e);
+               throw;
        }
 
        if (close)
@@ -1234,7 +1126,7 @@ void Paragraph::Private::latexSpecialChar(otexstream & os,
                                          BufferParams const & bparams,
                                          OutputParams const & runparams,
                                          Font const & running_font,
-                                         Change const & running_change,
+                                         string & alien_script,
                                          Layout const & style,
                                          pos_type & i,
                                          pos_type end_pos,
@@ -1266,7 +1158,7 @@ void Paragraph::Private::latexSpecialChar(otexstream & os,
            && !runparams.isFullUnicode() && bparams.main_font_encoding() == "T1"
            && latexSpecialT1(c, os, i, column))
                return;
-       // NOTE: XeTeX and LuaTeX use EU1/2 (pre 2017) or TU (as of 2017) encoding
+       // NOTE: "fontspec" (non-TeX fonts) sets the font encoding to "TU" (untill 2017 "EU1" or "EU2")
        else if (!runparams.inIPA && !running_font.language()->internalFontEncoding()
                 && runparams.isFullUnicode() && latexSpecialTU(c, os, i, column))
                     return;
@@ -1376,12 +1268,11 @@ void Paragraph::Private::latexSpecialChar(otexstream & os,
                                break;
                        }
                }
-               string script;
                pair<docstring, bool> latex = encoding.latexChar(c);
                docstring nextlatex;
                bool nexttipas = false;
                string nexttipashortcut;
-               if (next != '\0' && next != META_INSET && encoding.encodable(next)) {
+               if (next != '\0' && next != META_INSET && !encoding.encodable(next)) {
                        nextlatex = encoding.latexChar(next).first;
                        if (runparams.inIPA) {
                                nexttipashortcut = Encodings::TIPAShortcut(next);
@@ -1397,27 +1288,22 @@ void Paragraph::Private::latexSpecialChar(otexstream & os,
                                tipas = true;
                        }
                }
-               string fontenc;
-               fontenc = running_font.language()->fontenc(bparams);
-               // "Script chars" need to embraced in \textcyrillic and \textgreek notwithstanding
-               // whether they are encodable or not (it only depends on the font encoding),
-               // except if we are using fontspec.
-               if (!bparams.useNonTeXFonts && Encodings::isKnownScriptChar(c, script)) {
-                       docstring const wrapper = from_ascii("\\" + script + "{");
-                       docstring ltx = latex.first;
-                       if (!prefixIs(ltx, wrapper))
-                               ltx = wrapper + latex.first + from_ascii("}");
-                       column += writeScriptChars(bparams, runparams, os, ltx, running_change,
-                                                  encoding, fontenc, i) - 1;
-               } else if (latex.second
+               // eventually close "script wrapper" command (see `Paragraph::latex`)
+               if (!alien_script.empty()
+                       && alien_script != Encodings::isKnownScriptChar(next)) {
+                       column += latex.first.length();
+                       alien_script.clear();
+                       os << latex.first << "}";
+                       break;
+               }
+               if (latex.second
                         && ((!prefixIs(nextlatex, '\\')
                               && !prefixIs(nextlatex, '{')
                               && !prefixIs(nextlatex, '}'))
                             || (nexttipas
                                 && !prefixIs(from_ascii(nexttipashortcut), '\\')))
                         && !tipas) {
-                       // Prevent eating of a following
-                       // space or command corruption by
+                       // Prevent eating of a following space or command corruption by
                        // following characters
                        if (next == ' ' || next == '\0') {
                                column += latex.first.length() + 1;
@@ -1502,7 +1388,8 @@ void Paragraph::Private::validate(LaTeXFeatures & features) const
                otexstringstream os;
                os << layout_->preamble();
                size_t const length = os.length();
-               TeXOnePar(buf, buf.text(), buf.getParFromID(owner_->id()).pit(), os,
+               TeXOnePar(buf, *inset_owner_->getText(int(buf.getParFromID(owner_->id()).idx())),
+                         buf.getParFromID(owner_->id()).pit(), os,
                          features.runparams(), string(), 0, -1, true);
                if (os.length() > length)
                        features.addPreambleSnippet(os.release(), true);
@@ -1797,6 +1684,8 @@ void Paragraph::validate(LaTeXFeatures & features) const
        d->validate(features);
        bool fragile = features.runparams().moving_arg;
        fragile |= layout().needprotect;
+       if (inInset().getLayout().isNeedProtect())
+               fragile = true;
        if (needsCProtection(fragile))
                features.require("cprotect");
 }
@@ -1897,7 +1786,7 @@ Font const & Paragraph::getFontSettings(BufferParams const & bparams,
        // Optimisation: avoid a full font instantiation if there is no
        // language change from previous call.
        static Font previous_font;
-       static Language const * previous_lang = 0;
+       static Language const * previous_lang = nullptr;
        Language const * lang = getParLanguage(bparams);
        if (lang != previous_lang) {
                previous_lang = lang;
@@ -1945,7 +1834,7 @@ Font const & Paragraph::getFirstFontSettings(BufferParams const & bparams) const
        // Optimisation: avoid a full font instantiation if there is no
        // language change from previous call.
        static Font previous_font;
-       static Language const * previous_lang = 0;
+       static Language const * previous_lang = nullptr;
        if (bparams.language != previous_lang) {
                previous_lang = bparams.language;
                previous_font = Font(inherit_font, bparams.language);
@@ -2008,8 +1897,9 @@ char_type Paragraph::getUChar(BufferParams const & bparams,
        char_type c = d->text_[pos];
 
        // Return unchanged character in LTR languages
-       // or if we use poylglossia/bidi.
-       if (rp.use_polyglossia || !getFontSettings(bparams, pos).isRightToLeft())
+       // or if we use poylglossia/bidi (XeTeX).
+       if (rp.useBidiPackage()
+           || !getFontSettings(bparams, pos).isRightToLeft())
                return c;
 
        // Without polyglossia/bidi, we need to account for some special cases.
@@ -2028,7 +1918,8 @@ char_type Paragraph::getUChar(BufferParams const & bparams,
        char_type uc = c;
 
        // 1. In the following languages, parentheses need to be reversed.
-       bool const reverseparens = lang == "hebrew";
+       //    Also with polyglodia/luabidi
+       bool const reverseparens = (lang == "hebrew" || rp.use_polyglossia);
 
        // 2. In the following languages, brackets don't need to be reversed.
        bool const reversebrackets = lang != "arabic_arabtex"
@@ -2131,15 +2022,29 @@ depth_type Paragraph::getMaxDepthAfter() const
 }
 
 
-LyXAlignment Paragraph::getAlign() const
+LyXAlignment Paragraph::getAlign(BufferParams const & bparams) const
 {
        if (d->params_.align() == LYX_ALIGN_LAYOUT)
-               return d->layout_->align;
+               return getDefaultAlign(bparams);
        else
                return d->params_.align();
 }
 
 
+LyXAlignment Paragraph::getDefaultAlign(BufferParams const & bparams) const
+{
+       LyXAlignment res = layout().align;
+       if (isRTL(bparams)) {
+               // Swap sides
+               if (res == LYX_ALIGN_LEFT)
+                       res = LYX_ALIGN_RIGHT;
+               else if  (res == LYX_ALIGN_RIGHT)
+                       res = LYX_ALIGN_LEFT;
+       }
+       return res;
+}
+
+
 docstring const & Paragraph::labelString() const
 {
        return d->params_.labelString();
@@ -2170,13 +2075,6 @@ docstring Paragraph::expandLabel(Layout const & layout,
 }
 
 
-docstring Paragraph::expandDocBookLabel(Layout const & layout,
-               BufferParams const & bparams) const
-{
-       return expandParagraphLabel(layout, bparams, false);
-}
-
-
 docstring Paragraph::expandParagraphLabel(Layout const & layout,
                BufferParams const & bparams, bool process_appendix) const
 {
@@ -2239,15 +2137,17 @@ void Paragraph::setBeginOfBody()
        // remove unnecessary getChar() calls
        pos_type i = 0;
        pos_type end = size();
-       if (i < end && !(isNewline(i) || isEnvSeparator(i))) {
+       bool prev_char_deleted = false;
+       if (i < end && (!(isNewline(i) || isEnvSeparator(i)) || isDeleted(i))) {
                ++i;
                if (i < end) {
                        char_type previous_char = d->text_[i];
                        if (!(isNewline(i) || isEnvSeparator(i))) {
                                ++i;
-                               while (i < end && previous_char != ' ') {
+                               while (i < end && (previous_char != ' ' || prev_char_deleted)) {
                                        char_type temp = d->text_[i];
-                                       if (isNewline(i) || isEnvSeparator(i))
+                                       prev_char_deleted = isDeleted(i);
+                                       if (!isDeleted(i) && (isNewline(i) || isEnvSeparator(i)))
                                                break;
                                        ++i;
                                        previous_char = temp;
@@ -2379,8 +2279,9 @@ int Paragraph::Private::startTeXParParams(BufferParams const & bparams,
        InsetCode code = ownerCode();
        bool const lastpar = runparams.isLastPar;
        // RTL in classic (PDF)LaTeX (without the Bidi package)
+       // Luabibdi (used by LuaTeX) behaves like classic
        bool const rtl_classic = owner_->getParLanguage(bparams)->rightToLeft()
-               && !runparams.use_polyglossia;
+               && !runparams.useBidiPackage();
 
        switch (curAlign) {
        case LYX_ALIGN_NONE:
@@ -2442,8 +2343,9 @@ bool Paragraph::Private::endTeXParParams(BufferParams const & bparams,
        InsetCode code = ownerCode();
        bool const lastpar = runparams.isLastPar;
        // RTL in classic (PDF)LaTeX (without the Bidi package)
+       // Luabibdi (used by LuaTeX) behaves like classic
        bool const rtl_classic = owner_->getParLanguage(bparams)->rightToLeft()
-               && !runparams.use_polyglossia;
+               && !runparams.useBidiPackage();
 
        switch (curAlign) {
        case LYX_ALIGN_NONE:
@@ -2503,10 +2405,20 @@ void Paragraph::latex(BufferParams const & bparams,
        // of the body.
        Font basefont;
 
+       // If there is an open font-encoding changing command (script wrapper),
+       // alien_script is set to its name
+       string alien_script;
+       string script;
+
        // Maybe we have to create a optional argument.
        pos_type body_pos = beginOfBody();
        unsigned int column = 0;
 
+       // If we are inside an non inheritFont() inset, the real outerfont is local_font
+       Font const real_outerfont = (!inInset().inheritFont()
+                                    && runparams.local_font != nullptr)
+                       ? Font(runparams.local_font->fontInfo()) : outerfont;
+
        if (body_pos > 0) {
                // the optional argument is kept in curly brackets in
                // case it contains a ']'
@@ -2516,9 +2428,9 @@ void Paragraph::latex(BufferParams const & bparams,
                // braces when it parses \item.
                os << "[{";
                column += 2;
-               basefont = getLabelFont(bparams, outerfont);
+               basefont = getLabelFont(bparams, real_outerfont);
        } else {
-               basefont = getLayoutFont(bparams, outerfont);
+               basefont = getLayoutFont(bparams, real_outerfont);
        }
 
        // Which font is currently active?
@@ -2563,7 +2475,7 @@ void Paragraph::latex(BufferParams const & bparams,
                                                basefont, basefont, needPar);
                                        open_font = false;
                                }
-                               basefont = getLayoutFont(bparams, outerfont);
+                               basefont = getLayoutFont(bparams, real_outerfont);
                                running_font = basefont;
 
                                column += Changes::latexMarkChange(os, bparams,
@@ -2597,9 +2509,14 @@ void Paragraph::latex(BufferParams const & bparams,
                Change const & change = runparams.inDeletedInset
                        ? runparams.changeOfDeletedInset : lookupChange(i);
 
+               char_type const c = d->text_[i];
+
                // Check whether a display math inset follows
-               if (d->text_[i] == META_INSET
+               if (c == META_INSET
                    && i >= start_pos && (end_pos == -1 || i < end_pos)) {
+                       if (isDeleted(i))
+                               runparams.ctObject = getInset(i)->CtObject(runparams);
+       
                        InsetMath const * im = getInset(i)->asInsetMath();
                        if (im && im->asHullInset()
                            && im->asHullInset()->outerDisplay()) {
@@ -2625,7 +2542,8 @@ void Paragraph::latex(BufferParams const & bparams,
                                                basefont, needPar);
                                        open_font = false;
                                }
-                               basefont = getLayoutFont(bparams, outerfont);
+                               basefont = (body_pos > i) ? getLabelFont(bparams, real_outerfont)
+                                                         : getLayoutFont(bparams, real_outerfont);
                                running_font = basefont;
                                column += Changes::latexMarkChange(os, bparams,
                                        Change(Change::INSERTED), change, rp);
@@ -2633,6 +2551,11 @@ void Paragraph::latex(BufferParams const & bparams,
                }
 
                if (bparams.output_changes && runningChange != change) {
+                       if (!alien_script.empty()) {
+                               column += 1;
+                               os << "}";
+                               alien_script.clear();
+                       }
                        if (open_font) {
                                bool needPar = false;
                                column += running_font.latexWriteEndChanges(
@@ -2640,7 +2563,8 @@ void Paragraph::latex(BufferParams const & bparams,
                                                basefont, basefont, needPar);
                                open_font = false;
                        }
-                       basefont = getLayoutFont(bparams, outerfont);
+                       basefont = (body_pos > i) ? getLabelFont(bparams, real_outerfont)
+                                                 : getLayoutFont(bparams, real_outerfont);
                        running_font = basefont;
                        column += Changes::latexMarkChange(os, bparams, runningChange,
                                                           change, runparams);
@@ -2656,45 +2580,100 @@ void Paragraph::latex(BufferParams const & bparams,
                ++column;
 
                // Fully instantiated font
-               Font const current_font = getFont(bparams, i, outerfont);
+               Font current_font = getFont(bparams, i, outerfont);
+               // Previous font
+               Font const prev_font = (i > 0) ?
+                                       getFont(bparams, i - 1, outerfont)
+                                     : current_font;
 
                Font const last_font = running_font;
+               bool const in_ct_deletion = (bparams.output_changes
+                                            && runningChange == change
+                                            && change.type == Change::DELETED
+                                            && !os.afterParbreak());
+               // Insets where font switches are used (rather than font commands)
+               bool const fontswitch_inset =
+                               c == META_INSET
+                               && getInset(i)
+                               && getInset(i)->allowMultiPar()
+                               && getInset(i)->lyxCode() != ERT_CODE;
+
+               bool closeLanguage = false;
+               bool lang_switched_at_inset = false;
+               if (fontswitch_inset) {
+                       // Some insets cannot be inside a font change command.
+                       // However, even such insets *can* be placed in \L or \R
+                       // or their equivalents (for RTL language switches),
+                       // so we don't close the language in those cases
+                       // (= differing isRightToLeft()).
+                       // ArabTeX, though, doesn't seem to handle this special behavior.
+                       closeLanguage = basefont.isRightToLeft() == current_font.isRightToLeft()
+                                       || basefont.language()->lang() == "arabic_arabtex"
+                                       || current_font.language()->lang() == "arabic_arabtex";
+                       // We need to check prev_font as language changes directly at inset
+                       // will only be started inside the inset.
+                       lang_switched_at_inset = prev_font.language() != current_font.language();
+               }
 
                // Do we need to close the previous font?
+               bool langClosed = false;
                if (open_font &&
-                   (current_font != running_font ||
-                    current_font.language() != running_font.language()))
+                   ((current_font != running_font
+                     || current_font.language() != running_font.language())
+                    || (fontswitch_inset
+                        && (current_font == prev_font))))
                {
+                       // ensure there is no open script-wrapper
+                       if (!alien_script.empty()) {
+                               column += 1;
+                               os << "}";
+                               alien_script.clear();
+                       }
                        bool needPar = false;
+                       if (in_ct_deletion) {
+                               // We have to close and then reopen \lyxdeleted,
+                               // as strikeout needs to be on lowest level.
+                               os << '}';
+                               column += 1;
+                       }
+                       if (closeLanguage)
+                               // Force language closing
+                               current_font.setLanguage(basefont.language());
+                       Font const nextfont = (i == body_pos-1) ? basefont : current_font;
                        column += running_font.latexWriteEndChanges(
                                    os, bparams, runparams, basefont,
-                                   (i == body_pos-1) ? basefont : current_font,
-                                   needPar);
-                       running_font = basefont;
+                                   nextfont, needPar);
+                       if (in_ct_deletion) {
+                               // We have to close and then reopen \lyxdeleted,
+                               // as strikeout needs to be on lowest level.
+                               OutputParams rp = runparams;
+                               column += Changes::latexMarkChange(os, bparams,
+                                       Change(Change::UNCHANGED), Change(Change::DELETED), rp);
+                       }
                        open_font = false;
+                       // Has the language been closed in the latexWriteEndChanges() call above?
+                       langClosed = running_font.language() != basefont.language()
+                                       && running_font.language() != nextfont.language()
+                                       && (running_font.language()->encoding()->package() != Encoding::CJK);
+                       running_font = basefont;
                }
 
-               string const running_lang = runparams.use_polyglossia ?
-                       running_font.language()->polyglossia() : running_font.language()->babel();
-               // close babel's font environment before opening CJK.
-               string const lang_end_command = runparams.use_polyglossia ?
-                       "\\end{$$lang}" : lyxrc.language_command_end;
-               bool const using_begin_end = runparams.use_polyglossia ||
-                                               !lang_end_command.empty();
-               if (!running_lang.empty() &&
-                   (!using_begin_end || running_lang == openLanguageName()) &&
-                   current_font.language()->encoding()->package() == Encoding::CJK) {
-                               string end_tag = subst(lang_end_command,
-                                                       "$$lang",
-                                                       running_lang);
-                               os << from_ascii(end_tag);
-                               column += end_tag.length();
-                               if (using_begin_end)
-                                       popLanguageName();
+               // if necessary, close language environment before opening CJK
+               string const running_lang = running_font.language()->babel();
+               string const lang_end_command = lyxrc.language_command_end;
+               if (!lang_end_command.empty() && !bparams.useNonTeXFonts
+                       && !running_lang.empty()
+                       && running_lang == openLanguageName()
+                       && current_font.language()->encoding()->package() == Encoding::CJK) {
+                       string end_tag = subst(lang_end_command, "$$lang", running_lang);
+                       os << from_ascii(end_tag);
+                       column += end_tag.length();
+                       popLanguageName();
                }
 
                // Switch file encoding if necessary (and allowed)
-               if (!runparams.pass_thru && !style.pass_thru &&
+               if ((!fontswitch_inset || closeLanguage)
+                   && !runparams.pass_thru && !style.pass_thru &&
                    runparams.encoding->package() != Encoding::none &&
                    current_font.language()->encoding()->package() != Encoding::none) {
                        pair<bool, int> const enc_switch =
@@ -2706,8 +2685,6 @@ void Paragraph::latex(BufferParams const & bparams,
                        }
                }
 
-               char_type const c = d->text_[i];
-
                // A display math inset inside an ulem command will be output
                // as a box of width \linewidth, so we have to either disable
                // indentation if the inset starts a paragraph, or start a new
@@ -2723,37 +2700,63 @@ void Paragraph::latex(BufferParams const & bparams,
 
                // Do we need to change font?
                if ((current_font != running_font ||
-                    current_font.language() != running_font.language()) &&
-                       i != body_pos - 1)
+                    current_font.language() != running_font.language())
+                   && i != body_pos - 1)
                {
-                       odocstringstream ods;
-                       column += current_font.latexWriteStartChanges(ods, bparams,
-                                                             runparams, basefont,
-                                                             last_font);
-                       // Check again for display math in ulem commands as a
-                       // font change may also occur just before a math inset.
-                       if (runparams.inDisplayMath && !deleted_display_math
-                           && runparams.inulemcmd) {
-                               if (os.afterParbreak())
-                                       os << "\\noindent";
-                               else
-                                       os << "\\\\\n";
-                       }
-                       running_font = current_font;
-                       open_font = true;
-                       docstring fontchange = ods.str();
-                       // check whether the fontchange ends with a \\textcolor
-                       // modifier and the text starts with a space (bug 4473)
-                       docstring const last_modifier = rsplit(fontchange, '\\');
-                       if (prefixIs(last_modifier, from_ascii("textcolor")) && c == ' ')
-                               os << fontchange << from_ascii("{}");
-                       // check if the fontchange ends with a trailing blank
-                       // (like "\small " (see bug 3382)
-                       else if (suffixIs(fontchange, ' ') && c == ' ')
-                               os << fontchange.substr(0, fontchange.size() - 1)
-                                  << from_ascii("{}");
-                       else
+                       if (!fontswitch_inset) {
+                               if (in_ct_deletion) {
+                                       // We have to close and then reopen \lyxdeleted,
+                                       // as strikeout needs to be on lowest level.
+                                       bool needPar = false;
+                                       OutputParams rp = runparams;
+                                       column += running_font.latexWriteEndChanges(
+                                               os, bparams, rp, basefont,
+                                               basefont, needPar);
+                                       os << '}';
+                                       column += 1;
+                               }
+                               otexstringstream ots;
+                               InsetText const * textinset = inInset().asInsetText();
+                               bool const cprotect = textinset
+                                       ? textinset->hasCProtectContent(runparams.moving_arg)
+                                         && !textinset->text().isMainText()
+                                       : false;
+                               column += current_font.latexWriteStartChanges(ots, bparams,
+                                                                             runparams, basefont, last_font, false,
+                                                                             cprotect);
+                               // Check again for display math in ulem commands as a
+                               // font change may also occur just before a math inset.
+                               if (runparams.inDisplayMath && !deleted_display_math
+                                   && runparams.inulemcmd) {
+                                       if (os.afterParbreak())
+                                               os << "\\noindent";
+                                       else
+                                               os << "\\\\\n";
+                               }
+                               running_font = current_font;
+                               open_font = true;
+                               docstring fontchange = ots.str();
                                os << fontchange;
+                               // check whether the fontchange ends with a \\textcolor
+                               // modifier and the text starts with a space. If so we
+                               // need to add } in order to prevent \\textcolor from gobbling
+                               // the space (bug 4473).
+                               docstring const last_modifier = rsplit(fontchange, '\\');
+                               if (prefixIs(last_modifier, from_ascii("textcolor")) && c == ' ')
+                                       os << from_ascii("{}");
+                               else if (ots.terminateCommand())
+                                       os << termcmd;
+                               if (in_ct_deletion) {
+                                       // We have to close and then reopen \lyxdeleted,
+                                       // as strikeout needs to be on lowest level.
+                                       OutputParams rp = runparams;
+                                       column += Changes::latexMarkChange(os, bparams,
+                                               Change(Change::UNCHANGED), change, rp);
+                               }
+                       } else {
+                               running_font = current_font;
+                               open_font = !langClosed;
+                       }
                }
 
                // FIXME: think about end_pos implementation...
@@ -2795,7 +2798,7 @@ void Paragraph::latex(BufferParams const & bparams,
                                Inset const * inset = getInset(i);
                                InsetText const * textinset = inset
                                                        ? inset->asInsetText()
-                                                       : 0;
+                                                       : nullptr;
                                if (i + 1 == size() && textinset
                                    && !inset->getLayout().isDisplay()) {
                                        ParagraphList const & pars =
@@ -2805,27 +2808,67 @@ void Paragraph::latex(BufferParams const & bparams,
                                                pit < 0 || pars[pit].empty()
                                                ? pars[pit].getLayoutFont(
                                                                bparams,
-                                                               outerfont)
+                                                               real_outerfont)
                                                : pars[pit].getFont(bparams,
                                                        pars[pit].size() - 1,
-                                                       outerfont);
+                                                       real_outerfont);
                                        if (lastfont.fontInfo().size() !=
                                            basefont.fontInfo().size()) {
                                                ++parInline;
                                                incremented = true;
                                        }
                                }
+                               // We need to restore parts of this after insets with
+                               // allowMultiPar() true
+                               Font const save_basefont = basefont;
                                d->latexInset(bparams, os, rp, running_font,
-                                               basefont, outerfont, open_font,
-                                               runningChange, style, i, column);
+                                               basefont, real_outerfont, open_font,
+                                               runningChange, style, i, column, fontswitch_inset,
+                                               closeLanguage, lang_switched_at_inset);
+                               if (fontswitch_inset) {
+                                       if (open_font) {
+                                               bool needPar = false;
+                                               column += running_font.latexWriteEndChanges(
+                                                       os, bparams, runparams,
+                                                       basefont, basefont, needPar);
+                                               open_font = false;
+                                       }
+                                       basefont.fontInfo().setSize(save_basefont.fontInfo().size());
+                                       basefont.fontInfo().setFamily(save_basefont.fontInfo().family());
+                                       basefont.fontInfo().setSeries(save_basefont.fontInfo().series());
+                               }
                                if (incremented)
                                        --parInline;
+
+                               if (runparams.ctObject == OutputParams::CT_DISPLAYOBJECT
+                                   || runparams.ctObject == OutputParams::CT_UDISPLAYOBJECT) {
+                                       // Close \lyx*deleted and force its
+                                       // reopening (if needed)
+                                       os << '}';
+                                       column++;
+                                       runningChange = Change(Change::UNCHANGED);
+                                       runparams.ctObject = OutputParams::CT_NORMAL;
+                               }
                        }
                } else if (i >= start_pos && (end_pos == -1 || i < end_pos)) {
+                       if (!bparams.useNonTeXFonts)
+                         script = Encodings::isKnownScriptChar(c);
+                       if (script != alien_script) {
+                               if (!alien_script.empty()) {
+                                       os << "}";
+                                       alien_script.clear();
+                               }
+                               string fontenc = running_font.language()->fontenc(bparams);
+                               if (!script.empty()
+                                       && !Encodings::fontencSupportsScript(fontenc, script)) {
+                                       column += script.length() + 2;
+                                       os << "\\" << script << "{";
+                                       alien_script = script;
+                               }
+                       }
                        try {
-                               d->latexSpecialChar(os, bparams, rp,
-                                                   running_font, runningChange,
-                                                   style, i, end_pos, column);
+                               d->latexSpecialChar(os, bparams, rp, running_font,
+                                                                       alien_script, style, i, end_pos, column);
                        } catch (EncodingException & e) {
                                if (runparams.dryrun) {
                                        os << "<" << _("LyX Warning: ")
@@ -2836,7 +2879,7 @@ void Paragraph::latex(BufferParams const & bparams,
                                        // add location information and throw again.
                                        e.par_id = id();
                                        e.pos = i;
-                                       throw(e);
+                                       throw;
                                }
                        }
                }
@@ -2849,6 +2892,19 @@ void Paragraph::latex(BufferParams const & bparams,
                // such as Note that do not produce any output, so that no
                // command is ever executed but its opening was recorded.
                runparams.inulemcmd = rp.inulemcmd;
+
+               // These need to be passed upstream as well
+               runparams.need_maketitle = rp.need_maketitle;
+               runparams.have_maketitle = rp.have_maketitle;
+
+               // And finally, pass the post_macros upstream
+               runparams.post_macro = rp.post_macro;
+       }
+
+       // Close wrapper for alien script
+       if (!alien_script.empty()) {
+               os << "}";
+               alien_script.clear();
        }
 
        // If we have an open font definition, we have to close it
@@ -2864,8 +2920,8 @@ void Paragraph::latex(BufferParams const & bparams,
                // since this produces unwanted whitespace.
 
                Font const font = empty()
-                       ? getLayoutFont(bparams, outerfont)
-                       : getFont(bparams, size() - 1, outerfont);
+                       ? getLayoutFont(bparams, real_outerfont)
+                       : getFont(bparams, size() - 1, real_outerfont);
 
                InsetText const * textinset = inInset().asInsetText();
 
@@ -2960,7 +3016,7 @@ bool Paragraph::emptyTag() const
 }
 
 
-string Paragraph::getID(Buffer const & buf, OutputParams const & runparams)
+string Paragraph::getID(Buffer const &, OutputParams const &)
        const
 {
        for (pos_type i = 0; i < size(); ++i) {
@@ -2969,7 +3025,7 @@ string Paragraph::getID(Buffer const & buf, OutputParams const & runparams)
                        if (lyx_code == LABEL_CODE) {
                                InsetLabel const * const il = static_cast<InsetLabel const *>(inset);
                                docstring const & id = il->getParam("name");
-                               return "id='" + to_utf8(sgml::cleanID(buf, runparams, id)) + "'";
+                               return "id='" + to_utf8(xml::cleanID(id)) + "'";
                        }
                }
        }
@@ -2977,25 +3033,24 @@ string Paragraph::getID(Buffer const & buf, OutputParams const & runparams)
 }
 
 
-pos_type Paragraph::firstWordDocBook(odocstream & os, OutputParams const & runparams)
-       const
+pos_type Paragraph::firstWordDocBook(XMLStream & xs, OutputParams const & runparams) const
 {
        pos_type i;
        for (i = 0; i < size(); ++i) {
                if (Inset const * inset = getInset(i)) {
-                       inset->docbook(os, runparams);
+                       inset->docbook(xs, runparams);
                } else {
                        char_type c = d->text_[i];
                        if (c == ' ')
                                break;
-                       os << sgml::escapeChar(c);
+                       xs << c;
                }
        }
        return i;
 }
 
 
-pos_type Paragraph::firstWordLyXHTML(XHTMLStream & xs, OutputParams const & runparams)
+pos_type Paragraph::firstWordLyXHTML(XMLStream & xs, OutputParams const & runparams)
        const
 {
        pos_type i;
@@ -3030,78 +3085,404 @@ bool Paragraph::Private::onlyText(Buffer const & buf, Font const & outerfont, po
 }
 
 
-void Paragraph::simpleDocBookOnePar(Buffer const & buf,
-                                   odocstream & os,
-                                   OutputParams const & runparams,
-                                   Font const & outerfont,
-                                   pos_type initial) const
+namespace {
+
+void doFontSwitchDocBook(vector<xml::FontTag> & tagsToOpen,
+                  vector<xml::EndFontTag> & tagsToClose,
+                  bool & flag, FontState curstate, xml::FontTypes type)
+{
+       if (curstate == FONT_ON) {
+               tagsToOpen.push_back(docbookStartFontTag(type));
+               flag = true;
+       } else if (flag) {
+               tagsToClose.push_back(docbookEndFontTag(type));
+               flag = false;
+       }
+}
+
+class OptionalFontType {
+public:
+       xml::FontTypes ft;
+       bool has_value;
+
+       OptionalFontType(): ft(xml::FT_EMPH), has_value(false) {} // A possible value at random for ft.
+       OptionalFontType(xml::FontTypes ft): ft(ft), has_value(true) {}
+};
+
+OptionalFontType fontShapeToXml(FontShape fs)
+{
+       switch (fs) {
+       case ITALIC_SHAPE:
+               return {xml::FT_ITALIC};
+       case SLANTED_SHAPE:
+               return {xml::FT_SLANTED};
+       case SMALLCAPS_SHAPE:
+               return {xml::FT_SMALLCAPS};
+       case UP_SHAPE:
+       case INHERIT_SHAPE:
+               return {};
+       default:
+               // the other tags are for internal use
+               LATTEST(false);
+               return {};
+       }
+}
+
+OptionalFontType fontFamilyToXml(FontFamily fm)
 {
+       switch (fm) {
+       case ROMAN_FAMILY:
+               return {xml::FT_ROMAN};
+       case SANS_FAMILY:
+               return {xml::FT_SANS};
+       case TYPEWRITER_FAMILY:
+               return {xml::FT_TYPE};
+       case INHERIT_FAMILY:
+               return {};
+       default:
+               // the other tags are for internal use
+               LATTEST(false);
+               return {};
+       }
+}
+
+OptionalFontType fontSizeToXml(FontSize fs)
+{
+       switch (fs) {
+       case TINY_SIZE:
+               return {xml::FT_SIZE_TINY};
+       case SCRIPT_SIZE:
+               return {xml::FT_SIZE_SCRIPT};
+       case FOOTNOTE_SIZE:
+               return {xml::FT_SIZE_FOOTNOTE};
+       case SMALL_SIZE:
+               return {xml::FT_SIZE_SMALL};
+       case LARGE_SIZE:
+               return {xml::FT_SIZE_LARGE};
+       case LARGER_SIZE:
+               return {xml::FT_SIZE_LARGER};
+       case LARGEST_SIZE:
+               return {xml::FT_SIZE_LARGEST};
+       case HUGE_SIZE:
+               return {xml::FT_SIZE_HUGE};
+       case HUGER_SIZE:
+               return {xml::FT_SIZE_HUGER};
+       case INCREASE_SIZE:
+               return {xml::FT_SIZE_INCREASE};
+       case DECREASE_SIZE:
+               return {xml::FT_SIZE_DECREASE};
+       case INHERIT_SIZE:
+       case NORMAL_SIZE:
+               return {};
+       default:
+               // the other tags are for internal use
+               LATTEST(false);
+               return {};
+       }
+}
+
+struct DocBookFontState
+{
+       FontShape  curr_fs   = INHERIT_SHAPE;
+       FontFamily curr_fam  = INHERIT_FAMILY;
+       FontSize   curr_size = INHERIT_SIZE;
+
+       // track whether we have opened these tags
        bool emph_flag = false;
+       bool bold_flag = false;
+       bool noun_flag = false;
+       bool ubar_flag = false;
+       bool dbar_flag = false;
+       bool sout_flag = false;
+       bool xout_flag = false;
+       bool wave_flag = false;
+       // shape tags
+       bool shap_flag = false;
+       // family tags
+       bool faml_flag = false;
+       // size tags
+       bool size_flag = false;
+};
+
+std::tuple<vector<xml::FontTag>, vector<xml::EndFontTag>> computeDocBookFontSwitch(FontInfo const & font_old,
+                                                                                          Font const & font,
+                                                                                          std::string const & default_family,
+                                                                                          DocBookFontState & fs)
+{
+       vector<xml::FontTag> tagsToOpen;
+       vector<xml::EndFontTag> tagsToClose;
+
+       // emphasis
+       FontState curstate = font.fontInfo().emph();
+       if (font_old.emph() != curstate)
+               doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.emph_flag, curstate, xml::FT_EMPH);
+
+       // noun
+       curstate = font.fontInfo().noun();
+       if (font_old.noun() != curstate)
+               doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.noun_flag, curstate, xml::FT_NOUN);
+
+       // underbar
+       curstate = font.fontInfo().underbar();
+       if (font_old.underbar() != curstate)
+               doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.ubar_flag, curstate, xml::FT_UBAR);
+
+       // strikeout
+       curstate = font.fontInfo().strikeout();
+       if (font_old.strikeout() != curstate)
+               doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.sout_flag, curstate, xml::FT_SOUT);
+
+       // xout
+       curstate = font.fontInfo().xout();
+       if (font_old.xout() != curstate)
+               doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.xout_flag, curstate, xml::FT_XOUT);
+
+       // double underbar
+       curstate = font.fontInfo().uuline();
+       if (font_old.uuline() != curstate)
+               doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.dbar_flag, curstate, xml::FT_DBAR);
+
+       // wavy line
+       curstate = font.fontInfo().uwave();
+       if (font_old.uwave() != curstate)
+               doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.wave_flag, curstate, xml::FT_WAVE);
+
+       // bold
+       // a little hackish, but allows us to reuse what we have.
+       curstate = (font.fontInfo().series() == BOLD_SERIES ? FONT_ON : FONT_OFF);
+       if (font_old.series() != font.fontInfo().series())
+               doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.bold_flag, curstate, xml::FT_BOLD);
+
+       // Font shape
+       fs.curr_fs = font.fontInfo().shape();
+       FontShape old_fs = font_old.shape();
+       if (old_fs != fs.curr_fs) {
+               if (fs.shap_flag) {
+                       OptionalFontType tag = fontShapeToXml(old_fs);
+                       if (tag.has_value)
+                               tagsToClose.push_back(docbookEndFontTag(tag.ft));
+                       fs.shap_flag = false;
+               }
+
+               OptionalFontType tag = fontShapeToXml(fs.curr_fs);
+               if (tag.has_value)
+                       tagsToOpen.push_back(docbookStartFontTag(tag.ft));
+       }
+
+       // Font family
+       fs.curr_fam = font.fontInfo().family();
+       FontFamily old_fam = font_old.family();
+       if (old_fam != fs.curr_fam) {
+               if (fs.faml_flag) {
+                       OptionalFontType tag = fontFamilyToXml(old_fam);
+                       if (tag.has_value)
+                               tagsToClose.push_back(docbookEndFontTag(tag.ft));
+                       fs.faml_flag = false;
+               }
+               switch (fs.curr_fam) {
+                       case ROMAN_FAMILY:
+                               // we will treat a "default" font family as roman, since we have
+                               // no other idea what to do.
+                               if (default_family != "rmdefault" && default_family != "default") {
+                                       tagsToOpen.push_back(docbookStartFontTag(xml::FT_ROMAN));
+                                       fs.faml_flag = true;
+                               }
+                               break;
+                       case SANS_FAMILY:
+                               if (default_family != "sfdefault") {
+                                       tagsToOpen.push_back(docbookStartFontTag(xml::FT_SANS));
+                                       fs.faml_flag = true;
+                               }
+                               break;
+                       case TYPEWRITER_FAMILY:
+                               if (default_family != "ttdefault") {
+                                       tagsToOpen.push_back(docbookStartFontTag(xml::FT_TYPE));
+                                       fs.faml_flag = true;
+                               }
+                               break;
+                       case INHERIT_FAMILY:
+                               break;
+                       default:
+                               // the other tags are for internal use
+                               LATTEST(false);
+                               break;
+               }
+       }
+
+       // Font size
+       fs.curr_size = font.fontInfo().size();
+       FontSize old_size = font_old.size();
+       if (old_size != fs.curr_size) {
+               if (fs.size_flag) {
+                       OptionalFontType tag = fontSizeToXml(old_size);
+                       if (tag.has_value)
+                               tagsToClose.push_back(docbookEndFontTag(tag.ft));
+                       fs.size_flag = false;
+               }
+
+               OptionalFontType tag = fontSizeToXml(fs.curr_size);
+               if (tag.has_value) {
+                       tagsToOpen.push_back(docbookStartFontTag(tag.ft));
+                       fs.size_flag = true;
+               }
+       }
+
+       return std::tuple<vector<xml::FontTag>, vector<xml::EndFontTag>>(tagsToOpen, tagsToClose);
+}
+
+} // anonymous namespace
+
+
+std::vector<docstring> Paragraph::simpleDocBookOnePar(Buffer const & buf,
+                                                      OutputParams const & runparams,
+                                                      Font const & outerfont,
+                                                      pos_type initial,
+                                                      bool is_last_par,
+                                                      bool ignore_fonts) const
+{
+       // Track whether we have opened these tags
+       DocBookFontState fs;
 
        Layout const & style = *d->layout_;
        FontInfo font_old =
-               style.labeltype == LABEL_MANUAL ? style.labelfont : style.font;
+                       style.labeltype == LABEL_MANUAL ? style.labelfont : style.font;
+
+       string const default_family =
+                       buf.masterBuffer()->params().fonts_default_family;
 
-       if (style.pass_thru && !d->onlyText(buf, outerfont, initial))
-               os << "]]>";
+       vector<xml::FontTag> tagsToOpen;
+       vector<xml::EndFontTag> tagsToClose;
 
-       // parsing main loop
+       std::vector<docstring> generatedParagraphs;
+       DocBookFontState old_fs = fs;
+       odocstringstream os;
+       auto * xs = new XMLStream(os); // XMLStream has no copy constructor: to create a new object, the only solution
+       // is to hold a pointer to the XMLStream (xs = XMLStream(os) is not allowed once the first object is built).
+
+       // When a font tag ends with a space, output it after the closing font tag. This requires to store delayed
+       // characters at some point.
+       std::vector<char_type> delayedChars;
+
+       // Parsing main loop.
        for (pos_type i = initial; i < size(); ++i) {
-               Font font = getFont(buf.params(), i, outerfont);
-
-               // handle <emphasis> tag
-               if (font_old.emph() != font.fontInfo().emph()) {
-                       if (font.fontInfo().emph() == FONT_ON) {
-                               os << "<emphasis>";
-                               emph_flag = true;
-                       } else if (i != initial) {
-                               os << "</emphasis>";
-                               emph_flag = false;
+               // Don't show deleted material in the output.
+               if (isDeleted(i))
+                       continue;
+
+               // If this is an InsetNewline, generate a new paragraph. Also reset the fonts, so that tags are closed in
+               // this paragraph.
+               if (getInset(i) != nullptr && getInset(i)->lyxCode() == NEWLINE_CODE) {
+                       if (!ignore_fonts)
+                               xs->closeFontTags();
+
+                       // Output one paragraph (i.e. one string entry in generatedParagraphs).
+                       generatedParagraphs.push_back(os.str());
+
+                       // Create a new XMLStream for the new paragraph, completely independent from the previous one. This implies
+                       // that the string stream must be reset.
+                       os.str(from_ascii(""));
+                       delete xs;
+                       xs = new XMLStream(os);
+
+                       // Restore the fonts for the new paragraph, so that the right tags are opened for the new entry.
+                       if (!ignore_fonts) {
+                               font_old = outerfont.fontInfo();
+                               fs = old_fs;
                        }
                }
 
+               // Determine which tags should be opened or closed regarding fonts.
+               Font const font = getFont(buf.masterBuffer()->params(), i, outerfont);
+               if (!ignore_fonts) {
+                       tie(tagsToOpen, tagsToClose) = computeDocBookFontSwitch(font_old, font, default_family, fs);
+
+                       // FIXME XHTML
+                       // Other such tags? What about the other text ranges?
+
+                       vector<xml::EndFontTag>::const_iterator cit = tagsToClose.begin();
+                       vector<xml::EndFontTag>::const_iterator cen = tagsToClose.end();
+                       for (; cit != cen; ++cit)
+                               *xs << *cit;
+
+                       // Deal with the delayed characters *after* closing font tags.
+                       if (!delayedChars.empty()) {
+                               for (char_type c: delayedChars)
+                                       *xs << c;
+                               delayedChars.clear();
+                       }
+
+                       vector<xml::FontTag>::const_iterator sit = tagsToOpen.begin();
+                       vector<xml::FontTag>::const_iterator sen = tagsToOpen.end();
+                       for (; sit != sen; ++sit)
+                               *xs << *sit;
+
+                       tagsToClose.clear();
+                       tagsToOpen.clear();
+               }
+
                if (Inset const * inset = getInset(i)) {
-                       inset->docbook(os, runparams);
-               } else {
-                       char_type c = d->text_[i];
+                       if (!runparams.for_toc || inset->isInToc()) {
+                               OutputParams np = runparams;
+                               np.local_font = &font;
 
-                       if (style.pass_thru)
-                               os.put(c);
+                               // TODO: special case will bite here.
+                               np.docbook_in_par = true;
+                               inset->docbook(*xs, np);
+                       }
+               } else {
+                       char_type c = getUChar(buf.masterBuffer()->params(), runparams, i);
+                       if (lyx::isSpace(c) && !ignore_fonts)
+                               delayedChars.push_back(c);
                        else
-                               os << sgml::escapeChar(c);
+                               *xs << c;
                }
                font_old = font.fontInfo();
        }
 
-       if (emph_flag) {
-               os << "</emphasis>";
-       }
+       // FIXME, this code is just imported from XHTML
+       // I'm worried about what happens if a branch, say, is itself
+       // wrapped in some font stuff. I think that will not work.
+       if (!ignore_fonts)
+               xs->closeFontTags();
 
-       if (style.free_spacing)
-               os << '\n';
-       if (style.pass_thru && !d->onlyText(buf, outerfont, initial))
-               os << "<![CDATA[";
+       // Deal with the delayed characters *after* closing font tags.
+       if (!delayedChars.empty())
+               for (char_type c: delayedChars)
+                       *xs << c;
+
+       // In listings, new lines (i.e. \n characters in the output) are very important. Avoid generating one for the
+       // last line to get a clean output.
+       if (runparams.docbook_in_listing && !is_last_par)
+               *xs << xml::CR();
+
+       // Finalise the last (and most likely only) paragraph.
+       generatedParagraphs.push_back(os.str());
+       delete xs;
+
+       return generatedParagraphs;
 }
 
 
 namespace {
-void doFontSwitch(vector<html::FontTag> & tagsToOpen,
-                  vector<html::EndFontTag> & tagsToClose,
-                  bool & flag, FontState curstate, html::FontTypes type)
+
+void doFontSwitchXHTML(vector<xml::FontTag> & tagsToOpen,
+                  vector<xml::EndFontTag> & tagsToClose,
+                  bool & flag, FontState curstate, xml::FontTypes type)
 {
        if (curstate == FONT_ON) {
-               tagsToOpen.push_back(html::FontTag(type));
+               tagsToOpen.push_back(xhtmlStartFontTag(type));
                flag = true;
        } else if (flag) {
-               tagsToClose.push_back(html::EndFontTag(type));
+               tagsToClose.push_back(xhtmlEndFontTag(type));
                flag = false;
        }
 }
-} // namespace
+
+} // anonymous namespace
 
 
 docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
-                                   XHTMLStream & xs,
+                                   XMLStream & xs,
                                    OutputParams const & runparams,
                                    Font const & outerfont,
                                    bool start_paragraph, bool close_paragraph,
@@ -3135,13 +3516,13 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
 
        FontShape  curr_fs   = INHERIT_SHAPE;
        FontFamily curr_fam  = INHERIT_FAMILY;
-       FontSize   curr_size = FONT_SIZE_INHERIT;
+       FontSize   curr_size = INHERIT_SIZE;
 
        string const default_family =
                buf.masterBuffer()->params().fonts_default_family;
 
-       vector<html::FontTag> tagsToOpen;
-       vector<html::EndFontTag> tagsToClose;
+       vector<xml::FontTag> tagsToOpen;
+       vector<xml::EndFontTag> tagsToClose;
 
        // parsing main loop
        for (pos_type i = initial; i < size(); ++i) {
@@ -3154,43 +3535,43 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
                // emphasis
                FontState curstate = font.fontInfo().emph();
                if (font_old.emph() != curstate)
-                       doFontSwitch(tagsToOpen, tagsToClose, emph_flag, curstate, html::FT_EMPH);
+                       doFontSwitchXHTML(tagsToOpen, tagsToClose, emph_flag, curstate, xml::FT_EMPH);
 
                // noun
                curstate = font.fontInfo().noun();
                if (font_old.noun() != curstate)
-                       doFontSwitch(tagsToOpen, tagsToClose, noun_flag, curstate, html::FT_NOUN);
+                       doFontSwitchXHTML(tagsToOpen, tagsToClose, noun_flag, curstate, xml::FT_NOUN);
 
                // underbar
                curstate = font.fontInfo().underbar();
                if (font_old.underbar() != curstate)
-                       doFontSwitch(tagsToOpen, tagsToClose, ubar_flag, curstate, html::FT_UBAR);
+                       doFontSwitchXHTML(tagsToOpen, tagsToClose, ubar_flag, curstate, xml::FT_UBAR);
 
                // strikeout
                curstate = font.fontInfo().strikeout();
                if (font_old.strikeout() != curstate)
-                       doFontSwitch(tagsToOpen, tagsToClose, sout_flag, curstate, html::FT_SOUT);
+                       doFontSwitchXHTML(tagsToOpen, tagsToClose, sout_flag, curstate, xml::FT_SOUT);
 
                // xout
                curstate = font.fontInfo().xout();
                if (font_old.xout() != curstate)
-                       doFontSwitch(tagsToOpen, tagsToClose, xout_flag, curstate, html::FT_XOUT);
+                       doFontSwitchXHTML(tagsToOpen, tagsToClose, xout_flag, curstate, xml::FT_XOUT);
 
                // double underbar
                curstate = font.fontInfo().uuline();
                if (font_old.uuline() != curstate)
-                       doFontSwitch(tagsToOpen, tagsToClose, dbar_flag, curstate, html::FT_DBAR);
+                       doFontSwitchXHTML(tagsToOpen, tagsToClose, dbar_flag, curstate, xml::FT_DBAR);
 
                // wavy line
                curstate = font.fontInfo().uwave();
                if (font_old.uwave() != curstate)
-                       doFontSwitch(tagsToOpen, tagsToClose, wave_flag, curstate, html::FT_WAVE);
+                       doFontSwitchXHTML(tagsToOpen, tagsToClose, wave_flag, curstate, xml::FT_WAVE);
 
                // bold
                // a little hackish, but allows us to reuse what we have.
                curstate = (font.fontInfo().series() == BOLD_SERIES ? FONT_ON : FONT_OFF);
                if (font_old.series() != font.fontInfo().series())
-                       doFontSwitch(tagsToOpen, tagsToClose, bold_flag, curstate, html::FT_BOLD);
+                       doFontSwitchXHTML(tagsToOpen, tagsToClose, bold_flag, curstate, xml::FT_BOLD);
 
                // Font shape
                curr_fs = font.fontInfo().shape();
@@ -3199,13 +3580,13 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
                        if (shap_flag) {
                                switch (old_fs) {
                                case ITALIC_SHAPE:
-                                       tagsToClose.push_back(html::EndFontTag(html::FT_ITALIC));
+                                       tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_ITALIC));
                                        break;
                                case SLANTED_SHAPE:
-                                       tagsToClose.push_back(html::EndFontTag(html::FT_SLANTED));
+                                       tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SLANTED));
                                        break;
                                case SMALLCAPS_SHAPE:
-                                       tagsToClose.push_back(html::EndFontTag(html::FT_SMALLCAPS));
+                                       tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SMALLCAPS));
                                        break;
                                case UP_SHAPE:
                                case INHERIT_SHAPE:
@@ -3219,15 +3600,15 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
                        }
                        switch (curr_fs) {
                        case ITALIC_SHAPE:
-                               tagsToOpen.push_back(html::FontTag(html::FT_ITALIC));
+                               tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_ITALIC));
                                shap_flag = true;
                                break;
                        case SLANTED_SHAPE:
-                               tagsToOpen.push_back(html::FontTag(html::FT_SLANTED));
+                               tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SLANTED));
                                shap_flag = true;
                                break;
                        case SMALLCAPS_SHAPE:
-                               tagsToOpen.push_back(html::FontTag(html::FT_SMALLCAPS));
+                               tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SMALLCAPS));
                                shap_flag = true;
                                break;
                        case UP_SHAPE:
@@ -3247,13 +3628,13 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
                        if (faml_flag) {
                                switch (old_fam) {
                                case ROMAN_FAMILY:
-                                       tagsToClose.push_back(html::EndFontTag(html::FT_ROMAN));
+                                       tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_ROMAN));
                                        break;
                                case SANS_FAMILY:
-                                       tagsToClose.push_back(html::EndFontTag(html::FT_SANS));
-                                       break;
+                                   tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SANS));
+                                   break;
                                case TYPEWRITER_FAMILY:
-                                       tagsToClose.push_back(html::EndFontTag(html::FT_TYPE));
+                                       tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_TYPE));
                                        break;
                                case INHERIT_FAMILY:
                                        break;
@@ -3269,19 +3650,19 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
                                // we will treat a "default" font family as roman, since we have
                                // no other idea what to do.
                                if (default_family != "rmdefault" && default_family != "default") {
-                                       tagsToOpen.push_back(html::FontTag(html::FT_ROMAN));
+                                       tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_ROMAN));
                                        faml_flag = true;
                                }
                                break;
                        case SANS_FAMILY:
                                if (default_family != "sfdefault") {
-                                       tagsToOpen.push_back(html::FontTag(html::FT_SANS));
+                                       tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SANS));
                                        faml_flag = true;
                                }
                                break;
                        case TYPEWRITER_FAMILY:
                                if (default_family != "ttdefault") {
-                                       tagsToOpen.push_back(html::FontTag(html::FT_TYPE));
+                                       tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_TYPE));
                                        faml_flag = true;
                                }
                                break;
@@ -3300,41 +3681,41 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
                if (old_size != curr_size) {
                        if (size_flag) {
                                switch (old_size) {
-                               case FONT_SIZE_TINY:
-                                       tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_TINY));
+                               case TINY_SIZE:
+                                       tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_TINY));
                                        break;
-                               case FONT_SIZE_SCRIPT:
-                                       tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_SCRIPT));
+                               case SCRIPT_SIZE:
+                                       tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_SCRIPT));
                                        break;
-                               case FONT_SIZE_FOOTNOTE:
-                                       tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_FOOTNOTE));
+                               case FOOTNOTE_SIZE:
+                                       tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_FOOTNOTE));
                                        break;
-                               case FONT_SIZE_SMALL:
-                                       tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_SMALL));
+                               case SMALL_SIZE:
+                                       tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_SMALL));
                                        break;
-                               case FONT_SIZE_LARGE:
-                                       tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_LARGE));
+                               case LARGE_SIZE:
+                                       tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_LARGE));
                                        break;
-                               case FONT_SIZE_LARGER:
-                                       tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_LARGER));
+                               case LARGER_SIZE:
+                                       tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_LARGER));
                                        break;
-                               case FONT_SIZE_LARGEST:
-                                       tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_LARGEST));
+                               case LARGEST_SIZE:
+                                       tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_LARGEST));
                                        break;
-                               case FONT_SIZE_HUGE:
-                                       tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_HUGE));
+                               case HUGE_SIZE:
+                                       tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_HUGE));
                                        break;
-                               case FONT_SIZE_HUGER:
-                                       tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_HUGER));
+                               case HUGER_SIZE:
+                                       tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_HUGER));
                                        break;
-                               case FONT_SIZE_INCREASE:
-                                       tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_INCREASE));
+                               case INCREASE_SIZE:
+                                       tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_INCREASE));
                                        break;
-                               case FONT_SIZE_DECREASE:
-                                       tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_DECREASE));
+                               case DECREASE_SIZE:
+                                       tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_DECREASE));
                                        break;
-                               case FONT_SIZE_INHERIT:
-                               case FONT_SIZE_NORMAL:
+                               case INHERIT_SIZE:
+                               case NORMAL_SIZE:
                                        break;
                                default:
                                        // the other tags are for internal use
@@ -3344,52 +3725,52 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
                                size_flag = false;
                        }
                        switch (curr_size) {
-                       case FONT_SIZE_TINY:
-                               tagsToOpen.push_back(html::FontTag(html::FT_SIZE_TINY));
+                       case TINY_SIZE:
+                               tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_TINY));
                                size_flag = true;
                                break;
-                       case FONT_SIZE_SCRIPT:
-                               tagsToOpen.push_back(html::FontTag(html::FT_SIZE_SCRIPT));
+                       case SCRIPT_SIZE:
+                               tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_SCRIPT));
                                size_flag = true;
                                break;
-                       case FONT_SIZE_FOOTNOTE:
-                               tagsToOpen.push_back(html::FontTag(html::FT_SIZE_FOOTNOTE));
+                       case FOOTNOTE_SIZE:
+                               tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_FOOTNOTE));
                                size_flag = true;
                                break;
-                       case FONT_SIZE_SMALL:
-                               tagsToOpen.push_back(html::FontTag(html::FT_SIZE_SMALL));
+                       case SMALL_SIZE:
+                               tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_SMALL));
                                size_flag = true;
                                break;
-                       case FONT_SIZE_LARGE:
-                               tagsToOpen.push_back(html::FontTag(html::FT_SIZE_LARGE));
+                       case LARGE_SIZE:
+                               tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_LARGE));
                                size_flag = true;
                                break;
-                       case FONT_SIZE_LARGER:
-                               tagsToOpen.push_back(html::FontTag(html::FT_SIZE_LARGER));
+                       case LARGER_SIZE:
+                               tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_LARGER));
                                size_flag = true;
                                break;
-                       case FONT_SIZE_LARGEST:
-                               tagsToOpen.push_back(html::FontTag(html::FT_SIZE_LARGEST));
+                       case LARGEST_SIZE:
+                               tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_LARGEST));
                                size_flag = true;
                                break;
-                       case FONT_SIZE_HUGE:
-                               tagsToOpen.push_back(html::FontTag(html::FT_SIZE_HUGE));
+                       case HUGE_SIZE:
+                               tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_HUGE));
                                size_flag = true;
                                break;
-                       case FONT_SIZE_HUGER:
-                               tagsToOpen.push_back(html::FontTag(html::FT_SIZE_HUGER));
+                       case HUGER_SIZE:
+                               tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_HUGER));
                                size_flag = true;
                                break;
-                       case FONT_SIZE_INCREASE:
-                               tagsToOpen.push_back(html::FontTag(html::FT_SIZE_INCREASE));
+                       case INCREASE_SIZE:
+                               tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_INCREASE));
                                size_flag = true;
                                break;
-                       case FONT_SIZE_DECREASE:
-                               tagsToOpen.push_back(html::FontTag(html::FT_SIZE_DECREASE));
+                       case DECREASE_SIZE:
+                               tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_DECREASE));
                                size_flag = true;
                                break;
-                       case FONT_SIZE_NORMAL:
-                       case FONT_SIZE_INHERIT:
+                       case INHERIT_SIZE:
+                       case NORMAL_SIZE:
                                break;
                        default:
                                // the other tags are for internal use
@@ -3401,13 +3782,13 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
                // FIXME XHTML
                // Other such tags? What about the other text ranges?
 
-               vector<html::EndFontTag>::const_iterator cit = tagsToClose.begin();
-               vector<html::EndFontTag>::const_iterator cen = tagsToClose.end();
+               vector<xml::EndFontTag>::const_iterator cit = tagsToClose.begin();
+               vector<xml::EndFontTag>::const_iterator cen = tagsToClose.end();
                for (; cit != cen; ++cit)
                        xs << *cit;
 
-               vector<html::FontTag>::const_iterator sit = tagsToOpen.begin();
-               vector<html::FontTag>::const_iterator sen = tagsToOpen.end();
+               vector<xml::FontTag>::const_iterator sit = tagsToOpen.begin();
+               vector<xml::FontTag>::const_iterator sen = tagsToOpen.end();
                for (; sit != sen; ++sit)
                        xs << *sit;
 
@@ -3429,7 +3810,7 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
                        char_type c = getUChar(buf.masterBuffer()->params(),
                                               runparams, i);
                        if (c == ' ' && (style.free_spacing || runparams.free_spacing))
-                               xs << XHTMLStream::ESCAPE_NONE << "&nbsp;";
+                               xs << XMLStream::ESCAPE_NONE << "&nbsp;";
                        else
                                xs << c;
                }
@@ -3483,10 +3864,12 @@ bool Paragraph::isLineSeparator(pos_type pos) const
 }
 
 
-bool Paragraph::isWordSeparator(pos_type pos) const
+bool Paragraph::isWordSeparator(pos_type pos, bool const ignore_deleted) const
 {
        if (pos == size())
                return true;
+       if (ignore_deleted && isDeleted(pos))
+               return false;
        if (Inset const * inset = getInset(pos))
                return !inset->isLetter();
        // if we have a hard hyphen (no en- or emdash) or apostrophe
@@ -3511,8 +3894,8 @@ bool Paragraph::isHardHyphenOrApostrophe(pos_type pos) const
        char_type const c = d->text_[pos];
        if (c != '-' && c != '\'')
                return false;
-       int nextpos = pos + 1;
-       int prevpos = pos > 0 ? pos - 1 : 0;
+       pos_type nextpos = pos + 1;
+       pos_type prevpos = pos > 0 ? pos - 1 : 0;
        if ((nextpos == psize || isSpace(nextpos))
                && (pos == 0 || isSpace(prevpos)))
                return false;
@@ -3546,10 +3929,28 @@ bool Paragraph::needsCProtection(bool const fragile) const
        }
 
        // now check whether we have insets that need cprotection
-       pos_type size = d->text_.size();
-       for (pos_type i = 0; i < size; ++i)
-               if (isInset(i) && getInset(i)->needsCProtection(maintext, fragile))
+       pos_type size = pos_type(d->text_.size());
+       for (pos_type i = 0; i < size; ++i) {
+               if (!isInset(i))
+                       continue;
+               Inset const * ins = getInset(i);
+               if (ins->needsCProtection(maintext, fragile))
+                       return true;
+               // Now check math environments
+               InsetMath const * im = getInset(i)->asInsetMath();
+               if (!im || im->cell(0).empty())
+                       continue;
+               switch(im->cell(0)[0]->lyxCode()) {
+               case MATH_AMSARRAY_CODE:
+               case MATH_SUBSTACK_CODE:
+               case MATH_ENV_CODE:
+               case MATH_XYMATRIX_CODE:
+                       // these need cprotection
                        return true;
+               default:
+                       break;
+               }
+       }
 
        return false;
 }
@@ -3658,7 +4059,7 @@ docstring Paragraph::asString(pos_type beg, pos_type end, int options, const Out
                        os.put(c);
                else if (c == META_INSET && (options & AS_STR_INSETS)) {
                        if (c == META_INSET && (options & AS_STR_PLAINTEXT)) {
-                               LASSERT(runparams != 0, return docstring());
+                               LASSERT(runparams != nullptr, return docstring());
                                getInset(i)->plaintext(os, *runparams);
                        } else {
                                getInset(i)->toString(os);
@@ -3780,32 +4181,43 @@ bool Paragraph::allowEmpty() const
 
 bool Paragraph::brokenBiblio() const
 {
-       // there is a problem if there is no bibitem at position 0 or
-       // if there is another bibitem in the paragraph.
-       return d->layout_->labeltype == LABEL_BIBLIO
+       // There is a problem if there is no bibitem at position 0 in
+       // paragraphs that need one, if there is another bibitem in the
+       // paragraph or if this paragraph is not supposed to have
+       // a bibitem inset at all.
+       return ((d->layout_->labeltype == LABEL_BIBLIO
                && (d->insetlist_.find(BIBITEM_CODE) != 0
-                   || d->insetlist_.find(BIBITEM_CODE, 1) > 0);
+                   || d->insetlist_.find(BIBITEM_CODE, 1) > 0))
+               || (d->layout_->labeltype != LABEL_BIBLIO
+                   && d->insetlist_.find(BIBITEM_CODE) != -1));
 }
 
 
 int Paragraph::fixBiblio(Buffer const & buffer)
 {
-       // FIXME: What about the case where paragraph is not BIBLIO
-       // but there is an InsetBibitem?
        // FIXME: when there was already an inset at 0, the return value is 1,
-       // which does not tell whether another inset has been remove; the
+       // which does not tell whether another inset has been removed; the
        // cursor cannot be correctly updated.
 
-       if (d->layout_->labeltype != LABEL_BIBLIO)
-               return 0;
-
        bool const track_changes = buffer.params().track_changes;
        int bibitem_pos = d->insetlist_.find(BIBITEM_CODE);
-       bool const hasbibitem0 = bibitem_pos == 0;
 
+       // The case where paragraph is not BIBLIO
+       if (d->layout_->labeltype != LABEL_BIBLIO) {
+               if (bibitem_pos == -1)
+                       // No InsetBibitem => OK
+                       return 0;
+               // There is an InsetBibitem: remove it!
+               d->insetlist_.release(bibitem_pos);
+               eraseChar(bibitem_pos, track_changes);
+               return (bibitem_pos == 0) ? -1 : -bibitem_pos;
+       }
+
+       bool const hasbibitem0 = bibitem_pos == 0;
        if (hasbibitem0) {
                bibitem_pos = d->insetlist_.find(BIBITEM_CODE, 1);
-               // There was an InsetBibitem at pos 0, and no other one => OK
+               // There was an InsetBibitem at pos 0,
+               // and no other one => OK
                if (bibitem_pos == -1)
                        return 0;
                // there is a bibitem at the 0 position, but since
@@ -3816,11 +4228,13 @@ int Paragraph::fixBiblio(Buffer const & buffer)
                // than keep the first? (JMarc)
                Inset * inset = releaseInset(bibitem_pos);
                d->insetlist_.begin()->inset = inset;
+               // This needs to be done to update the counter (#8499)
+               buffer.updateBuffer();
                return -bibitem_pos;
        }
 
        // We need to create an inset at the beginning
-       Inset * inset = 0;
+       Inset * inset = nullptr;
        if (bibitem_pos > 0) {
                // there was one somewhere in the paragraph, let's move it
                inset = d->insetlist_.release(bibitem_pos);
@@ -3834,6 +4248,8 @@ int Paragraph::fixBiblio(Buffer const & buffer)
        insertInset(0, inset, font, Change(track_changes ? Change::INSERTED
                                                   : Change::UNCHANGED));
 
+       // This is needed to get the counters right
+       buffer.updateBuffer();
        return 1;
 }
 
@@ -3892,14 +4308,14 @@ Inset * Paragraph::releaseInset(pos_type pos)
 Inset * Paragraph::getInset(pos_type pos)
 {
        return (pos < pos_type(d->text_.size()) && d->text_[pos] == META_INSET)
-                ? d->insetlist_.get(pos) : 0;
+                ? d->insetlist_.get(pos) : nullptr;
 }
 
 
 Inset const * Paragraph::getInset(pos_type pos) const
 {
        return (pos < pos_type(d->text_.size()) && d->text_[pos] == META_INSET)
-                ? d->insetlist_.get(pos) : 0;
+                ? d->insetlist_.get(pos) : nullptr;
 }
 
 
@@ -3953,10 +4369,8 @@ void Paragraph::changeCase(BufferParams const & bparams, pos_type pos,
                }
 
                int erasePos = pos - changes.size();
-               for (size_t i = 0; i < changes.size(); i++) {
-                       insertChar(pos, changes[i].first,
-                                  changes[i].second,
-                                  trackChanges);
+               for (auto const & change : changes) {
+                       insertChar(pos, change.first, change.second, trackChanges);
                        if (!eraseChar(erasePos, trackChanges)) {
                                ++erasePos;
                                ++pos; // advance
@@ -3979,9 +4393,12 @@ int Paragraph::find(docstring const & str, bool cs, bool mw,
                // Ignore "invisible" letters such as ligature breaks
                // and hyphenation chars while searching
                while (pos < parsize - 1 && isInset(pos)) {
+                       Inset const * inset = getInset(pos);
+                       if (!inset->isLetter())
+                               break;
                        odocstringstream os;
-                       getInset(pos)->toString(os);
-                       if (!getInset(pos)->isLetter() || !os.str().empty())
+                       inset->toString(os);
+                       if (!os.str().empty())
                                break;
                        pos++;
                }
@@ -4056,13 +4473,13 @@ void Paragraph::deregisterWords()
 
 
 void Paragraph::locateWord(pos_type & from, pos_type & to,
-       word_location const loc) const
+       word_location const loc, bool const ignore_deleted) const
 {
        switch (loc) {
        case WHOLE_WORD_STRICT:
                if (from == 0 || from == size()
-                   || isWordSeparator(from)
-                   || isWordSeparator(from - 1)) {
+                   || isWordSeparator(from, ignore_deleted)
+                   || isWordSeparator(from - 1, ignore_deleted)) {
                        to = from;
                        return;
                }
@@ -4070,13 +4487,13 @@ void Paragraph::locateWord(pos_type & from, pos_type & to,
 
        case WHOLE_WORD:
                // If we are already at the beginning of a word, do nothing
-               if (!from || isWordSeparator(from - 1))
+               if (!from || isWordSeparator(from - 1, ignore_deleted))
                        break;
                // fall through
 
        case PREVIOUS_WORD:
                // always move the cursor to the beginning of previous word
-               while (from && !isWordSeparator(from - 1))
+               while (from && !isWordSeparator(from - 1, ignore_deleted))
                        --from;
                break;
        case NEXT_WORD:
@@ -4087,7 +4504,7 @@ void Paragraph::locateWord(pos_type & from, pos_type & to,
                break;
        }
        to = from;
-       while (to < size() && !isWordSeparator(to))
+       while (to < size() && !isWordSeparator(to, ignore_deleted))
                ++to;
 }
 
@@ -4166,7 +4583,7 @@ Language * Paragraph::Private::locateSpellRange(
                ++from;
        // don't check empty range
        if (from >= to)
-               return 0;
+               return nullptr;
        // get current language
        Language * lang = getSpellLanguage(from);
        pos_type last = from;
@@ -4175,7 +4592,18 @@ Language * Paragraph::Private::locateSpellRange(
        while (last < to && samelang && sameinset) {
                // hop to end of word
                while (last < to && !owner_->isWordSeparator(last)) {
-                       if (owner_->getInset(last)) {
+                       Inset const * inset = owner_->getInset(last);
+                       if (inset && dynamic_cast<const InsetSpecialChar *>(inset)) {
+                               // check for "invisible" letters such as ligature breaks
+                               odocstringstream os;
+                               inset->toString(os);
+                               if (os.str().length() != 0) {
+                                       // avoid spell check of visible special char insets
+                                       // stop the loop in front of the special char inset
+                                       sameinset = false;
+                                       break;
+                               }
+                       } else if (inset) {
                                appendSkipPosition(skips, last);
                        } else if (owner_->isDeleted(last)) {
                                appendSkipPosition(skips, last);
@@ -4267,7 +4695,7 @@ SpellChecker::Result Paragraph::spellCheck(pos_type & from, pos_type & to,
        if (!d->layout_->spellcheck || !inInset().allowSpellCheck())
                return result;
 
-       locateWord(from, to, WHOLE_WORD);
+       locateWord(from, to, WHOLE_WORD, true);
        if (from == to || from >= size())
                return result;
 
@@ -4401,7 +4829,7 @@ void Paragraph::spellCheck() const
                        // start the spell checker on the unit of meaning
                        docstring word = asString(first, last, AS_STR_INSETS + AS_STR_SKIPDELETE);
                        WordLangTuple wl = WordLangTuple(word, lang);
-                       SpellChecker::Result result = word.size() ?
+                       SpellChecker::Result result = !word.empty() ?
                                speller->check(wl) : SpellChecker::WORD_OK;
                        d->markMisspelledWords(first, last, result, word, skips);
                        first = ++last;